FreeNAS RESTful API

AcmeDnsAuthenticator

acmeDnsAuthenticatorAuthenticatorSchemasGet

Get the schemas for all DNS providers we support for ACME DNS Challenge and the respective attributes required for connecting to them while validating a DNS Challenge


/acme/dns/authenticator/authenticator_schemas

Usage and SDK Samples

curl -X GET -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/acme/dns/authenticator/authenticator_schemas"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.AcmeDnsAuthenticatorApi;

import java.io.File;
import java.util.*;

public class AcmeDnsAuthenticatorApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        AcmeDnsAuthenticatorApi apiInstance = new AcmeDnsAuthenticatorApi();
        try {
            apiInstance.acmeDnsAuthenticatorAuthenticatorSchemasGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling AcmeDnsAuthenticatorApi#acmeDnsAuthenticatorAuthenticatorSchemasGet");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::AcmeDnsAuthenticatorApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::AcmeDnsAuthenticatorApi->new();

eval { 
    $api_instance->acmeDnsAuthenticatorAuthenticatorSchemasGet();
};
if ($@) {
    warn "Exception when calling AcmeDnsAuthenticatorApi->acmeDnsAuthenticatorAuthenticatorSchemasGet: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.AcmeDnsAuthenticatorApi()

try: 
    api_instance.acme_dns_authenticator_authenticator_schemas_get()
except ApiException as e:
    print("Exception when calling AcmeDnsAuthenticatorApi->acmeDnsAuthenticatorAuthenticatorSchemasGet: %s\n" % e)

Parameters

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


acmeDnsAuthenticatorGet


/acme/dns/authenticator

Usage and SDK Samples

curl -X GET -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/acme/dns/authenticator?limit=&offset=&count=&sort="
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.AcmeDnsAuthenticatorApi;

import java.io.File;
import java.util.*;

public class AcmeDnsAuthenticatorApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        AcmeDnsAuthenticatorApi apiInstance = new AcmeDnsAuthenticatorApi();
        Integer limit = 56; // Integer | 
        Integer offset = 56; // Integer | 
        Boolean count = true; // Boolean | 
        String sort = sort_example; // String | 
        try {
            apiInstance.acmeDnsAuthenticatorGet(limit, offset, count, sort);
        } catch (ApiException e) {
            System.err.println("Exception when calling AcmeDnsAuthenticatorApi#acmeDnsAuthenticatorGet");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::AcmeDnsAuthenticatorApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::AcmeDnsAuthenticatorApi->new();
my $limit = 56; # Integer | 
my $offset = 56; # Integer | 
my $count = true; # Boolean | 
my $sort = sort_example; # String | 

eval { 
    $api_instance->acmeDnsAuthenticatorGet(limit => $limit, offset => $offset, count => $count, sort => $sort);
};
if ($@) {
    warn "Exception when calling AcmeDnsAuthenticatorApi->acmeDnsAuthenticatorGet: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.AcmeDnsAuthenticatorApi()
limit = 56 # Integer |  (optional)
offset = 56 # Integer |  (optional)
count = true # Boolean |  (optional)
sort = sort_example # String |  (optional)

try: 
    api_instance.acme_dns_authenticator_get(limit=limit, offset=offset, count=count, sort=sort)
except ApiException as e:
    print("Exception when calling AcmeDnsAuthenticatorApi->acmeDnsAuthenticatorGet: %s\n" % e)

Parameters

Query parameters
Name Description
limit
Integer
offset
Integer
count
Boolean
sort
String

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


acmeDnsAuthenticatorIdIdDelete

Delete DNS Authenticator of `id`


/acme/dns/authenticator/id/{id}

Usage and SDK Samples

curl -X DELETE -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/acme/dns/authenticator/id/{id}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.AcmeDnsAuthenticatorApi;

import java.io.File;
import java.util.*;

public class AcmeDnsAuthenticatorApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        AcmeDnsAuthenticatorApi apiInstance = new AcmeDnsAuthenticatorApi();
        Integer id = 56; // Integer | 
        try {
            apiInstance.acmeDnsAuthenticatorIdIdDelete(id);
        } catch (ApiException e) {
            System.err.println("Exception when calling AcmeDnsAuthenticatorApi#acmeDnsAuthenticatorIdIdDelete");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::AcmeDnsAuthenticatorApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::AcmeDnsAuthenticatorApi->new();
my $id = 56; # Integer | 

eval { 
    $api_instance->acmeDnsAuthenticatorIdIdDelete(id => $id);
};
if ($@) {
    warn "Exception when calling AcmeDnsAuthenticatorApi->acmeDnsAuthenticatorIdIdDelete: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.AcmeDnsAuthenticatorApi()
id = 56 # Integer | 

try: 
    api_instance.acme_dns_authenticator_id_id_delete(id)
except ApiException as e:
    print("Exception when calling AcmeDnsAuthenticatorApi->acmeDnsAuthenticatorIdIdDelete: %s\n" % e)

Parameters

Path parameters
Name Description
id*
Integer
Required

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


acmeDnsAuthenticatorIdIdGet


/acme/dns/authenticator/id/{id}

Usage and SDK Samples

curl -X GET -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/acme/dns/authenticator/id/{id}?limit=&offset=&count=&sort="
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.AcmeDnsAuthenticatorApi;

import java.io.File;
import java.util.*;

public class AcmeDnsAuthenticatorApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        AcmeDnsAuthenticatorApi apiInstance = new AcmeDnsAuthenticatorApi();
        array[null] id = ; // array[null] | 
        Integer limit = 56; // Integer | 
        Integer offset = 56; // Integer | 
        Boolean count = true; // Boolean | 
        String sort = sort_example; // String | 
        try {
            apiInstance.acmeDnsAuthenticatorIdIdGet(id, limit, offset, count, sort);
        } catch (ApiException e) {
            System.err.println("Exception when calling AcmeDnsAuthenticatorApi#acmeDnsAuthenticatorIdIdGet");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::AcmeDnsAuthenticatorApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::AcmeDnsAuthenticatorApi->new();
my $id = []; # array[null] | 
my $limit = 56; # Integer | 
my $offset = 56; # Integer | 
my $count = true; # Boolean | 
my $sort = sort_example; # String | 

eval { 
    $api_instance->acmeDnsAuthenticatorIdIdGet(id => $id, limit => $limit, offset => $offset, count => $count, sort => $sort);
};
if ($@) {
    warn "Exception when calling AcmeDnsAuthenticatorApi->acmeDnsAuthenticatorIdIdGet: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.AcmeDnsAuthenticatorApi()
id =  # array[null] | 
limit = 56 # Integer |  (optional)
offset = 56 # Integer |  (optional)
count = true # Boolean |  (optional)
sort = sort_example # String |  (optional)

try: 
    api_instance.acme_dns_authenticator_id_id_get(id, limit=limit, offset=offset, count=count, sort=sort)
except ApiException as e:
    print("Exception when calling AcmeDnsAuthenticatorApi->acmeDnsAuthenticatorIdIdGet: %s\n" % e)

Parameters

Path parameters
Name Description
id*
array[null]
Required
Query parameters
Name Description
limit
Integer
offset
Integer
count
Boolean
sort
String

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


acmeDnsAuthenticatorIdIdPut

Update DNS Authenticator of `id`


/acme/dns/authenticator/id/{id}

Usage and SDK Samples

curl -X PUT -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/acme/dns/authenticator/id/{id}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.AcmeDnsAuthenticatorApi;

import java.io.File;
import java.util.*;

public class AcmeDnsAuthenticatorApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        AcmeDnsAuthenticatorApi apiInstance = new AcmeDnsAuthenticatorApi();
        Integer id = 56; // Integer | 
        Acme_dns_authenticator_update_1 body = ; // Acme_dns_authenticator_update_1 | 
        try {
            apiInstance.acmeDnsAuthenticatorIdIdPut(id, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling AcmeDnsAuthenticatorApi#acmeDnsAuthenticatorIdIdPut");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::AcmeDnsAuthenticatorApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::AcmeDnsAuthenticatorApi->new();
my $id = 56; # Integer | 
my $body = WWW::SwaggerClient::Object::Acme_dns_authenticator_update_1->new(); # Acme_dns_authenticator_update_1 | 

eval { 
    $api_instance->acmeDnsAuthenticatorIdIdPut(id => $id, body => $body);
};
if ($@) {
    warn "Exception when calling AcmeDnsAuthenticatorApi->acmeDnsAuthenticatorIdIdPut: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.AcmeDnsAuthenticatorApi()
id = 56 # Integer | 
body =  # Acme_dns_authenticator_update_1 |  (optional)

try: 
    api_instance.acme_dns_authenticator_id_id_put(id, body=body)
except ApiException as e:
    print("Exception when calling AcmeDnsAuthenticatorApi->acmeDnsAuthenticatorIdIdPut: %s\n" % e)

Parameters

Path parameters
Name Description
id*
Integer
Required
Body parameters
Name Description
body

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


acmeDnsAuthenticatorPost

Create a DNS Authenticator Create a specific DNS Authenticator containing required authentication details for the said provider to successfully connect with it


/acme/dns/authenticator

Usage and SDK Samples

curl -X POST -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/acme/dns/authenticator"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.AcmeDnsAuthenticatorApi;

import java.io.File;
import java.util.*;

public class AcmeDnsAuthenticatorApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        AcmeDnsAuthenticatorApi apiInstance = new AcmeDnsAuthenticatorApi();
        Acme_dns_authenticator_create_0 body = ; // Acme_dns_authenticator_create_0 | 
        try {
            apiInstance.acmeDnsAuthenticatorPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling AcmeDnsAuthenticatorApi#acmeDnsAuthenticatorPost");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::AcmeDnsAuthenticatorApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::AcmeDnsAuthenticatorApi->new();
my $body = WWW::SwaggerClient::Object::Acme_dns_authenticator_create_0->new(); # Acme_dns_authenticator_create_0 | 

eval { 
    $api_instance->acmeDnsAuthenticatorPost(body => $body);
};
if ($@) {
    warn "Exception when calling AcmeDnsAuthenticatorApi->acmeDnsAuthenticatorPost: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.AcmeDnsAuthenticatorApi()
body =  # Acme_dns_authenticator_create_0 |  (optional)

try: 
    api_instance.acme_dns_authenticator_post(body=body)
except ApiException as e:
    print("Exception when calling AcmeDnsAuthenticatorApi->acmeDnsAuthenticatorPost: %s\n" % e)

Parameters

Body parameters
Name Description
body

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


Activedirectory

activedirectoryChangeTrustAccountPwGet

Force an update of the AD machine account password. This can be used to refresh the Kerberos principals in the server's system keytab.


/activedirectory/change_trust_account_pw

Usage and SDK Samples

curl -X GET -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/activedirectory/change_trust_account_pw"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.ActivedirectoryApi;

import java.io.File;
import java.util.*;

public class ActivedirectoryApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        ActivedirectoryApi apiInstance = new ActivedirectoryApi();
        try {
            apiInstance.activedirectoryChangeTrustAccountPwGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling ActivedirectoryApi#activedirectoryChangeTrustAccountPwGet");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::ActivedirectoryApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::ActivedirectoryApi->new();

eval { 
    $api_instance->activedirectoryChangeTrustAccountPwGet();
};
if ($@) {
    warn "Exception when calling ActivedirectoryApi->activedirectoryChangeTrustAccountPwGet: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.ActivedirectoryApi()

try: 
    api_instance.activedirectory_change_trust_account_pw_get()
except ApiException as e:
    print("Exception when calling ActivedirectoryApi->activedirectoryChangeTrustAccountPwGet: %s\n" % e)

Parameters

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


activedirectoryDomainInfoGet

Returns the following information about the currently joined domain: `LDAP server` IP address of current LDAP server to which TrueNAS is connected. `LDAP server name` DNS name of LDAP server to which TrueNAS is connected `Realm` Kerberos realm `LDAP port` `Server time` timestamp. `KDC server` Kerberos KDC to which TrueNAS is connected `Server time offset` current time offset from DC. `Last machine account password change`. timestamp


/activedirectory/domain_info

Usage and SDK Samples

curl -X GET -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/activedirectory/domain_info"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.ActivedirectoryApi;

import java.io.File;
import java.util.*;

public class ActivedirectoryApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        ActivedirectoryApi apiInstance = new ActivedirectoryApi();
        try {
            apiInstance.activedirectoryDomainInfoGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling ActivedirectoryApi#activedirectoryDomainInfoGet");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::ActivedirectoryApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::ActivedirectoryApi->new();

eval { 
    $api_instance->activedirectoryDomainInfoGet();
};
if ($@) {
    warn "Exception when calling ActivedirectoryApi->activedirectoryDomainInfoGet: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.ActivedirectoryApi()

try: 
    api_instance.activedirectory_domain_info_get()
except ApiException as e:
    print("Exception when calling ActivedirectoryApi->activedirectoryDomainInfoGet: %s\n" % e)

Parameters

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


activedirectoryGet


/activedirectory

Usage and SDK Samples

curl -X GET -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/activedirectory"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.ActivedirectoryApi;

import java.io.File;
import java.util.*;

public class ActivedirectoryApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        ActivedirectoryApi apiInstance = new ActivedirectoryApi();
        try {
            apiInstance.activedirectoryGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling ActivedirectoryApi#activedirectoryGet");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::ActivedirectoryApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::ActivedirectoryApi->new();

eval { 
    $api_instance->activedirectoryGet();
};
if ($@) {
    warn "Exception when calling ActivedirectoryApi->activedirectoryGet: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.ActivedirectoryApi()

try: 
    api_instance.activedirectory_get()
except ApiException as e:
    print("Exception when calling ActivedirectoryApi->activedirectoryGet: %s\n" % e)

Parameters

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


activedirectoryGetSpnListGet

Return list of kerberos SPN entries registered for the server's Active Directory computer account. This may not reflect the state of the server's current kerberos keytab.


/activedirectory/get_spn_list

Usage and SDK Samples

curl -X GET -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/activedirectory/get_spn_list"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.ActivedirectoryApi;

import java.io.File;
import java.util.*;

public class ActivedirectoryApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        ActivedirectoryApi apiInstance = new ActivedirectoryApi();
        try {
            apiInstance.activedirectoryGetSpnListGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling ActivedirectoryApi#activedirectoryGetSpnListGet");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::ActivedirectoryApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::ActivedirectoryApi->new();

eval { 
    $api_instance->activedirectoryGetSpnListGet();
};
if ($@) {
    warn "Exception when calling ActivedirectoryApi->activedirectoryGetSpnListGet: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.ActivedirectoryApi()

try: 
    api_instance.activedirectory_get_spn_list_get()
except ApiException as e:
    print("Exception when calling ActivedirectoryApi->activedirectoryGetSpnListGet: %s\n" % e)

Parameters

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


activedirectoryGetStateGet

Wrapper function for 'directoryservices.get_state'. Returns only the state of the Active Directory service.


/activedirectory/get_state

Usage and SDK Samples

curl -X GET -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/activedirectory/get_state"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.ActivedirectoryApi;

import java.io.File;
import java.util.*;

public class ActivedirectoryApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        ActivedirectoryApi apiInstance = new ActivedirectoryApi();
        try {
            apiInstance.activedirectoryGetStateGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling ActivedirectoryApi#activedirectoryGetStateGet");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::ActivedirectoryApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::ActivedirectoryApi->new();

eval { 
    $api_instance->activedirectoryGetStateGet();
};
if ($@) {
    warn "Exception when calling ActivedirectoryApi->activedirectoryGetStateGet: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.ActivedirectoryApi()

try: 
    api_instance.activedirectory_get_state_get()
except ApiException as e:
    print("Exception when calling ActivedirectoryApi->activedirectoryGetStateGet: %s\n" % e)

Parameters

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


activedirectoryLeavePost

Leave Active Directory domain. This will remove computer object from AD and clear relevant configuration data from the NAS. This requires credentials for appropriately-privileged user. Credentials are used to obtain a kerberos ticket, which is used to perform the actual removal from the domain.


/activedirectory/leave

Usage and SDK Samples

curl -X POST -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/activedirectory/leave"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.ActivedirectoryApi;

import java.io.File;
import java.util.*;

public class ActivedirectoryApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        ActivedirectoryApi apiInstance = new ActivedirectoryApi();
        Activedirectory_leave_0 body = ; // Activedirectory_leave_0 | 
        try {
            apiInstance.activedirectoryLeavePost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling ActivedirectoryApi#activedirectoryLeavePost");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::ActivedirectoryApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::ActivedirectoryApi->new();
my $body = WWW::SwaggerClient::Object::Activedirectory_leave_0->new(); # Activedirectory_leave_0 | 

eval { 
    $api_instance->activedirectoryLeavePost(body => $body);
};
if ($@) {
    warn "Exception when calling ActivedirectoryApi->activedirectoryLeavePost: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.ActivedirectoryApi()
body =  # Activedirectory_leave_0 |  (optional)

try: 
    api_instance.activedirectory_leave_post(body=body)
except ApiException as e:
    print("Exception when calling ActivedirectoryApi->activedirectoryLeavePost: %s\n" % e)

Parameters

Body parameters
Name Description
body

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


activedirectoryNssInfoChoicesGet

Returns list of available LDAP schema choices.


/activedirectory/nss_info_choices

Usage and SDK Samples

curl -X GET -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/activedirectory/nss_info_choices"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.ActivedirectoryApi;

import java.io.File;
import java.util.*;

public class ActivedirectoryApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        ActivedirectoryApi apiInstance = new ActivedirectoryApi();
        try {
            apiInstance.activedirectoryNssInfoChoicesGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling ActivedirectoryApi#activedirectoryNssInfoChoicesGet");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::ActivedirectoryApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::ActivedirectoryApi->new();

eval { 
    $api_instance->activedirectoryNssInfoChoicesGet();
};
if ($@) {
    warn "Exception when calling ActivedirectoryApi->activedirectoryNssInfoChoicesGet: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.ActivedirectoryApi()

try: 
    api_instance.activedirectory_nss_info_choices_get()
except ApiException as e:
    print("Exception when calling ActivedirectoryApi->activedirectoryNssInfoChoicesGet: %s\n" % e)

Parameters

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


activedirectoryPut

Update active directory configuration. `domainname` full DNS domain name of the Active Directory domain. `bindname` username used to perform the intial domain join. `bindpw` password used to perform the initial domain join. User- provided credentials are used to obtain a kerberos ticket, which is used to perform the actual domain join. `verbose_logging` increase logging during the domain join process. `use_default_domain` controls whether domain users and groups have the pre-windows 2000 domain name prepended to the user account. When enabled, the user appears as "administrator" rather than "EXAMPLEdministrator" `allow_trusted_doms` enable support for trusted domains. If this parameter is enabled, then separate idmap backends _must_ be configured for each trusted domain, and the idmap cache should be cleared. `allow_dns_updates` during the domain join process, automatically generate DNS entries in the AD domain for the NAS. If this is disabled, then a domain administrator must manually add appropriate DNS entries for the NAS. This parameter is recommended for TrueNAS HA servers. `disable_freenas_cache` disables active caching of AD users and groups. When disabled, only users cached in winbind's internal cache are visible in GUI dropdowns. Disabling active caching is recommended in environments with a large amount of users. `site` AD site of which the NAS is a member. This parameter is auto- detected during the domain join process. If no AD site is configured for the subnet in which the NAS is configured, then this parameter appears as 'Default-First-Site-Name'. Auto-detection is only performed during the initial domain join. `kerberos_realm` in which the server is located. This parameter is automatically populated during the initial domain join. If the NAS has an AD site configured and that site has multiple kerberos servers, then the kerberos realm is automatically updated with a site-specific configuration to use those servers. Auto-detection is only performed during initial domain join. `kerberos_principal` kerberos principal to use for AD-related operations outside of Samba. After intial domain join, this field is updated with the kerberos principal associated with the AD machine account for the NAS. `nss_info` controls how Winbind retrieves Name Service Information to construct a user's home directory and login shell. This parameter is only effective if the Active Directory Domain Controller supports the Microsoft Services for Unix (SFU) LDAP schema. `timeout` timeout value for winbind-related operations. This value may need to be increased in environments with high latencies for communications with domain controllers or a large number of domain controllers. Lowering the value may cause status checks to fail. `dns_timeout` timeout value for DNS queries during the initial domain join. This value is also set as the NETWORK_TIMEOUT in the ldap config file. `createcomputer` Active Directory Organizational Unit in which new computer accounts are created. The OU string is read from top to bottom without RDNs. Slashes ("/") are used as delimiters, like `Computers/Servers/NAS`. The backslash ("\") is used to escape characters but not as a separator. Backslashes are interpreted at multiple levels and might require doubling or even quadrupling to take effect. When this field is blank, new computer accounts are created in the Active Directory default OU. The Active Directory service is started after a configuration update if the service was initially disabled, and the updated configuration sets `enable` to `True`. The Active Directory service is stopped if `enable` is changed to `False`. If the configuration is updated, but the initial `enable` state is `True`, and remains unchanged, then the samba server is only restarted. During the domain join, a kerberos keytab for the newly-created AD machine account is generated. It is used for all future LDAP / AD interaction and the user-provided credentials are removed.


/activedirectory

Usage and SDK Samples

curl -X PUT -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/activedirectory"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.ActivedirectoryApi;

import java.io.File;
import java.util.*;

public class ActivedirectoryApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        ActivedirectoryApi apiInstance = new ActivedirectoryApi();
        Activedirectory_update_0 body = ; // Activedirectory_update_0 | 
        try {
            apiInstance.activedirectoryPut(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling ActivedirectoryApi#activedirectoryPut");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::ActivedirectoryApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::ActivedirectoryApi->new();
my $body = WWW::SwaggerClient::Object::Activedirectory_update_0->new(); # Activedirectory_update_0 | 

eval { 
    $api_instance->activedirectoryPut(body => $body);
};
if ($@) {
    warn "Exception when calling ActivedirectoryApi->activedirectoryPut: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.ActivedirectoryApi()
body =  # Activedirectory_update_0 |  (optional)

try: 
    api_instance.activedirectory_put(body=body)
except ApiException as e:
    print("Exception when calling ActivedirectoryApi->activedirectoryPut: %s\n" % e)

Parameters

Body parameters
Name Description
body

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


activedirectoryStartedGet

Issue a no-effect command to our DC. This checks if our secure channel connection to our domain controller is still alive. It has much less impact than wbinfo -t. Default winbind request timeout is 60 seconds, and can be adjusted by the smb4.conf parameter 'winbind request timeout ='


/activedirectory/started

Usage and SDK Samples

curl -X GET -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/activedirectory/started"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.ActivedirectoryApi;

import java.io.File;
import java.util.*;

public class ActivedirectoryApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        ActivedirectoryApi apiInstance = new ActivedirectoryApi();
        try {
            apiInstance.activedirectoryStartedGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling ActivedirectoryApi#activedirectoryStartedGet");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::ActivedirectoryApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::ActivedirectoryApi->new();

eval { 
    $api_instance->activedirectoryStartedGet();
};
if ($@) {
    warn "Exception when calling ActivedirectoryApi->activedirectoryStartedGet: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.ActivedirectoryApi()

try: 
    api_instance.activedirectory_started_get()
except ApiException as e:
    print("Exception when calling ActivedirectoryApi->activedirectoryStartedGet: %s\n" % e)

Parameters

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


Afp

afpBindipChoicesGet

List of valid choices for IP addresses to which to bind the AFP service.


/afp/bindip_choices

Usage and SDK Samples

curl -X GET -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/afp/bindip_choices"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.AfpApi;

import java.io.File;
import java.util.*;

public class AfpApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        AfpApi apiInstance = new AfpApi();
        try {
            apiInstance.afpBindipChoicesGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling AfpApi#afpBindipChoicesGet");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::AfpApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::AfpApi->new();

eval { 
    $api_instance->afpBindipChoicesGet();
};
if ($@) {
    warn "Exception when calling AfpApi->afpBindipChoicesGet: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.AfpApi()

try: 
    api_instance.afp_bindip_choices_get()
except ApiException as e:
    print("Exception when calling AfpApi->afpBindipChoicesGet: %s\n" % e)

Parameters

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


afpGet


/afp

Usage and SDK Samples

curl -X GET -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/afp"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.AfpApi;

import java.io.File;
import java.util.*;

public class AfpApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        AfpApi apiInstance = new AfpApi();
        try {
            apiInstance.afpGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling AfpApi#afpGet");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::AfpApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::AfpApi->new();

eval { 
    $api_instance->afpGet();
};
if ($@) {
    warn "Exception when calling AfpApi->afpGet: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.AfpApi()

try: 
    api_instance.afp_get()
except ApiException as e:
    print("Exception when calling AfpApi->afpGet: %s\n" % e)

Parameters

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


afpPut

Update AFP service settings. `bindip` is a list of IPs to bind AFP to. Leave blank (empty list) to bind to all available IPs. `map_acls` defines how to map the effective permissions of authenticated users. RIGHTS - Unix-style permissions MODE - ACLs NONE - Do not map `chmod_request` defines advanced permission control that deals with ACLs. PRESERVE - Preserve ZFS ACEs for named users and groups or POSIX ACL group mask SIMPLE - Change permission as requested without any extra steps IGNORE - Permission change requests are ignored


/afp

Usage and SDK Samples

curl -X PUT -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/afp"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.AfpApi;

import java.io.File;
import java.util.*;

public class AfpApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        AfpApi apiInstance = new AfpApi();
        Afp_update_0 body = ; // Afp_update_0 | 
        try {
            apiInstance.afpPut(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling AfpApi#afpPut");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::AfpApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::AfpApi->new();
my $body = WWW::SwaggerClient::Object::Afp_update_0->new(); # Afp_update_0 | 

eval { 
    $api_instance->afpPut(body => $body);
};
if ($@) {
    warn "Exception when calling AfpApi->afpPut: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.AfpApi()
body =  # Afp_update_0 |  (optional)

try: 
    api_instance.afp_put(body=body)
except ApiException as e:
    print("Exception when calling AfpApi->afpPut: %s\n" % e)

Parameters

Body parameters
Name Description
body

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


Alert

alertDismissPost

Dismiss `id` alert.


/alert/dismiss

Usage and SDK Samples

curl -X POST -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/alert/dismiss"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.AlertApi;

import java.io.File;
import java.util.*;

public class AlertApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        AlertApi apiInstance = new AlertApi();
        String body = ; // String | 
        try {
            apiInstance.alertDismissPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling AlertApi#alertDismissPost");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::AlertApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::AlertApi->new();
my $body = WWW::SwaggerClient::Object::String->new(); # String | 

eval { 
    $api_instance->alertDismissPost(body => $body);
};
if ($@) {
    warn "Exception when calling AlertApi->alertDismissPost: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.AlertApi()
body =  # String |  (optional)

try: 
    api_instance.alert_dismiss_post(body=body)
except ApiException as e:
    print("Exception when calling AlertApi->alertDismissPost: %s\n" % e)

Parameters

Body parameters
Name Description
body

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


alertListCategoriesGet

List all types of alerts which the system can issue.


/alert/list_categories

Usage and SDK Samples

curl -X GET -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/alert/list_categories"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.AlertApi;

import java.io.File;
import java.util.*;

public class AlertApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        AlertApi apiInstance = new AlertApi();
        try {
            apiInstance.alertListCategoriesGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling AlertApi#alertListCategoriesGet");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::AlertApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::AlertApi->new();

eval { 
    $api_instance->alertListCategoriesGet();
};
if ($@) {
    warn "Exception when calling AlertApi->alertListCategoriesGet: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.AlertApi()

try: 
    api_instance.alert_list_categories_get()
except ApiException as e:
    print("Exception when calling AlertApi->alertListCategoriesGet: %s\n" % e)

Parameters

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


alertListGet

List all types of alerts including active/dismissed currently in the system.


/alert/list

Usage and SDK Samples

curl -X GET -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/alert/list"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.AlertApi;

import java.io.File;
import java.util.*;

public class AlertApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        AlertApi apiInstance = new AlertApi();
        try {
            apiInstance.alertListGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling AlertApi#alertListGet");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::AlertApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::AlertApi->new();

eval { 
    $api_instance->alertListGet();
};
if ($@) {
    warn "Exception when calling AlertApi->alertListGet: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.AlertApi()

try: 
    api_instance.alert_list_get()
except ApiException as e:
    print("Exception when calling AlertApi->alertListGet: %s\n" % e)

Parameters

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


alertListPoliciesGet

List all alert policies which indicate the frequency of the alerts.


/alert/list_policies

Usage and SDK Samples

curl -X GET -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/alert/list_policies"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.AlertApi;

import java.io.File;
import java.util.*;

public class AlertApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        AlertApi apiInstance = new AlertApi();
        try {
            apiInstance.alertListPoliciesGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling AlertApi#alertListPoliciesGet");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::AlertApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::AlertApi->new();

eval { 
    $api_instance->alertListPoliciesGet();
};
if ($@) {
    warn "Exception when calling AlertApi->alertListPoliciesGet: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.AlertApi()

try: 
    api_instance.alert_list_policies_get()
except ApiException as e:
    print("Exception when calling AlertApi->alertListPoliciesGet: %s\n" % e)

Parameters

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


alertRestorePost

Restore `id` alert which had been dismissed.


/alert/restore

Usage and SDK Samples

curl -X POST -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/alert/restore"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.AlertApi;

import java.io.File;
import java.util.*;

public class AlertApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        AlertApi apiInstance = new AlertApi();
        String body = ; // String | 
        try {
            apiInstance.alertRestorePost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling AlertApi#alertRestorePost");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::AlertApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::AlertApi->new();
my $body = WWW::SwaggerClient::Object::String->new(); # String | 

eval { 
    $api_instance->alertRestorePost(body => $body);
};
if ($@) {
    warn "Exception when calling AlertApi->alertRestorePost: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.AlertApi()
body =  # String |  (optional)

try: 
    api_instance.alert_restore_post(body=body)
except ApiException as e:
    print("Exception when calling AlertApi->alertRestorePost: %s\n" % e)

Parameters

Body parameters
Name Description
body

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


Alertclasses

alertclassesGet


/alertclasses

Usage and SDK Samples

curl -X GET -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/alertclasses"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.AlertclassesApi;

import java.io.File;
import java.util.*;

public class AlertclassesApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        AlertclassesApi apiInstance = new AlertclassesApi();
        try {
            apiInstance.alertclassesGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling AlertclassesApi#alertclassesGet");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::AlertclassesApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::AlertclassesApi->new();

eval { 
    $api_instance->alertclassesGet();
};
if ($@) {
    warn "Exception when calling AlertclassesApi->alertclassesGet: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.AlertclassesApi()

try: 
    api_instance.alertclasses_get()
except ApiException as e:
    print("Exception when calling AlertclassesApi->alertclassesGet: %s\n" % e)

Parameters

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


alertclassesPut

Update default Alert settings.


/alertclasses

Usage and SDK Samples

curl -X PUT -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/alertclasses"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.AlertclassesApi;

import java.io.File;
import java.util.*;

public class AlertclassesApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        AlertclassesApi apiInstance = new AlertclassesApi();
        Alertclasses_update_0 body = ; // Alertclasses_update_0 | 
        try {
            apiInstance.alertclassesPut(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling AlertclassesApi#alertclassesPut");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::AlertclassesApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::AlertclassesApi->new();
my $body = WWW::SwaggerClient::Object::Alertclasses_update_0->new(); # Alertclasses_update_0 | 

eval { 
    $api_instance->alertclassesPut(body => $body);
};
if ($@) {
    warn "Exception when calling AlertclassesApi->alertclassesPut: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.AlertclassesApi()
body =  # Alertclasses_update_0 |  (optional)

try: 
    api_instance.alertclasses_put(body=body)
except ApiException as e:
    print("Exception when calling AlertclassesApi->alertclassesPut: %s\n" % e)

Parameters

Body parameters
Name Description
body

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


Alertservice

alertserviceGet


/alertservice

Usage and SDK Samples

curl -X GET -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/alertservice?limit=&offset=&count=&sort="
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.AlertserviceApi;

import java.io.File;
import java.util.*;

public class AlertserviceApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        AlertserviceApi apiInstance = new AlertserviceApi();
        Integer limit = 56; // Integer | 
        Integer offset = 56; // Integer | 
        Boolean count = true; // Boolean | 
        String sort = sort_example; // String | 
        try {
            apiInstance.alertserviceGet(limit, offset, count, sort);
        } catch (ApiException e) {
            System.err.println("Exception when calling AlertserviceApi#alertserviceGet");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::AlertserviceApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::AlertserviceApi->new();
my $limit = 56; # Integer | 
my $offset = 56; # Integer | 
my $count = true; # Boolean | 
my $sort = sort_example; # String | 

eval { 
    $api_instance->alertserviceGet(limit => $limit, offset => $offset, count => $count, sort => $sort);
};
if ($@) {
    warn "Exception when calling AlertserviceApi->alertserviceGet: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.AlertserviceApi()
limit = 56 # Integer |  (optional)
offset = 56 # Integer |  (optional)
count = true # Boolean |  (optional)
sort = sort_example # String |  (optional)

try: 
    api_instance.alertservice_get(limit=limit, offset=offset, count=count, sort=sort)
except ApiException as e:
    print("Exception when calling AlertserviceApi->alertserviceGet: %s\n" % e)

Parameters

Query parameters
Name Description
limit
Integer
offset
Integer
count
Boolean
sort
String

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


alertserviceIdIdDelete

Delete Alert Service of `id`.


/alertservice/id/{id}

Usage and SDK Samples

curl -X DELETE -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/alertservice/id/{id}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.AlertserviceApi;

import java.io.File;
import java.util.*;

public class AlertserviceApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        AlertserviceApi apiInstance = new AlertserviceApi();
        Integer id = 56; // Integer | 
        try {
            apiInstance.alertserviceIdIdDelete(id);
        } catch (ApiException e) {
            System.err.println("Exception when calling AlertserviceApi#alertserviceIdIdDelete");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::AlertserviceApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::AlertserviceApi->new();
my $id = 56; # Integer | 

eval { 
    $api_instance->alertserviceIdIdDelete(id => $id);
};
if ($@) {
    warn "Exception when calling AlertserviceApi->alertserviceIdIdDelete: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.AlertserviceApi()
id = 56 # Integer | 

try: 
    api_instance.alertservice_id_id_delete(id)
except ApiException as e:
    print("Exception when calling AlertserviceApi->alertserviceIdIdDelete: %s\n" % e)

Parameters

Path parameters
Name Description
id*
Integer
Required

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


alertserviceIdIdGet


/alertservice/id/{id}

Usage and SDK Samples

curl -X GET -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/alertservice/id/{id}?limit=&offset=&count=&sort="
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.AlertserviceApi;

import java.io.File;
import java.util.*;

public class AlertserviceApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        AlertserviceApi apiInstance = new AlertserviceApi();
        array[null] id = ; // array[null] | 
        Integer limit = 56; // Integer | 
        Integer offset = 56; // Integer | 
        Boolean count = true; // Boolean | 
        String sort = sort_example; // String | 
        try {
            apiInstance.alertserviceIdIdGet(id, limit, offset, count, sort);
        } catch (ApiException e) {
            System.err.println("Exception when calling AlertserviceApi#alertserviceIdIdGet");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::AlertserviceApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::AlertserviceApi->new();
my $id = []; # array[null] | 
my $limit = 56; # Integer | 
my $offset = 56; # Integer | 
my $count = true; # Boolean | 
my $sort = sort_example; # String | 

eval { 
    $api_instance->alertserviceIdIdGet(id => $id, limit => $limit, offset => $offset, count => $count, sort => $sort);
};
if ($@) {
    warn "Exception when calling AlertserviceApi->alertserviceIdIdGet: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.AlertserviceApi()
id =  # array[null] | 
limit = 56 # Integer |  (optional)
offset = 56 # Integer |  (optional)
count = true # Boolean |  (optional)
sort = sort_example # String |  (optional)

try: 
    api_instance.alertservice_id_id_get(id, limit=limit, offset=offset, count=count, sort=sort)
except ApiException as e:
    print("Exception when calling AlertserviceApi->alertserviceIdIdGet: %s\n" % e)

Parameters

Path parameters
Name Description
id*
array[null]
Required
Query parameters
Name Description
limit
Integer
offset
Integer
count
Boolean
sort
String

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


alertserviceIdIdPut

Update Alert Service of `id`.


/alertservice/id/{id}

Usage and SDK Samples

curl -X PUT -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/alertservice/id/{id}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.AlertserviceApi;

import java.io.File;
import java.util.*;

public class AlertserviceApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        AlertserviceApi apiInstance = new AlertserviceApi();
        Integer id = 56; // Integer | 
        Alertservice_update_1 body = ; // Alertservice_update_1 | 
        try {
            apiInstance.alertserviceIdIdPut(id, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling AlertserviceApi#alertserviceIdIdPut");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::AlertserviceApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::AlertserviceApi->new();
my $id = 56; # Integer | 
my $body = WWW::SwaggerClient::Object::Alertservice_update_1->new(); # Alertservice_update_1 | 

eval { 
    $api_instance->alertserviceIdIdPut(id => $id, body => $body);
};
if ($@) {
    warn "Exception when calling AlertserviceApi->alertserviceIdIdPut: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.AlertserviceApi()
id = 56 # Integer | 
body =  # Alertservice_update_1 |  (optional)

try: 
    api_instance.alertservice_id_id_put(id, body=body)
except ApiException as e:
    print("Exception when calling AlertserviceApi->alertserviceIdIdPut: %s\n" % e)

Parameters

Path parameters
Name Description
id*
Integer
Required
Body parameters
Name Description
body

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


alertserviceListTypesGet

List all types of supported Alert services which can be configured with the system.


/alertservice/list_types

Usage and SDK Samples

curl -X GET -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/alertservice/list_types"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.AlertserviceApi;

import java.io.File;
import java.util.*;

public class AlertserviceApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        AlertserviceApi apiInstance = new AlertserviceApi();
        try {
            apiInstance.alertserviceListTypesGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling AlertserviceApi#alertserviceListTypesGet");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::AlertserviceApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::AlertserviceApi->new();

eval { 
    $api_instance->alertserviceListTypesGet();
};
if ($@) {
    warn "Exception when calling AlertserviceApi->alertserviceListTypesGet: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.AlertserviceApi()

try: 
    api_instance.alertservice_list_types_get()
except ApiException as e:
    print("Exception when calling AlertserviceApi->alertserviceListTypesGet: %s\n" % e)

Parameters

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


alertservicePost

Create an Alert Service of specified `type`. If `enabled`, it sends alerts to the configured `type` of Alert Service.


/alertservice

Usage and SDK Samples

curl -X POST -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/alertservice"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.AlertserviceApi;

import java.io.File;
import java.util.*;

public class AlertserviceApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        AlertserviceApi apiInstance = new AlertserviceApi();
        Alertservice_create_0 body = ; // Alertservice_create_0 | 
        try {
            apiInstance.alertservicePost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling AlertserviceApi#alertservicePost");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::AlertserviceApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::AlertserviceApi->new();
my $body = WWW::SwaggerClient::Object::Alertservice_create_0->new(); # Alertservice_create_0 | 

eval { 
    $api_instance->alertservicePost(body => $body);
};
if ($@) {
    warn "Exception when calling AlertserviceApi->alertservicePost: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.AlertserviceApi()
body =  # Alertservice_create_0 |  (optional)

try: 
    api_instance.alertservice_post(body=body)
except ApiException as e:
    print("Exception when calling AlertserviceApi->alertservicePost: %s\n" % e)

Parameters

Body parameters
Name Description
body

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


alertserviceTestPost

Send a test alert using `type` of Alert Service.


/alertservice/test

Usage and SDK Samples

curl -X POST -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/alertservice/test"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.AlertserviceApi;

import java.io.File;
import java.util.*;

public class AlertserviceApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        AlertserviceApi apiInstance = new AlertserviceApi();
        Alertservice_test_0 body = ; // Alertservice_test_0 | 
        try {
            apiInstance.alertserviceTestPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling AlertserviceApi#alertserviceTestPost");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::AlertserviceApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::AlertserviceApi->new();
my $body = WWW::SwaggerClient::Object::Alertservice_test_0->new(); # Alertservice_test_0 | 

eval { 
    $api_instance->alertserviceTestPost(body => $body);
};
if ($@) {
    warn "Exception when calling AlertserviceApi->alertserviceTestPost: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.AlertserviceApi()
body =  # Alertservice_test_0 |  (optional)

try: 
    api_instance.alertservice_test_post(body=body)
except ApiException as e:
    print("Exception when calling AlertserviceApi->alertserviceTestPost: %s\n" % e)

Parameters

Body parameters
Name Description
body

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


ApiKey

apiKeyGet


/api_key

Usage and SDK Samples

curl -X GET -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/api_key?limit=&offset=&count=&sort="
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.ApiKeyApi;

import java.io.File;
import java.util.*;

public class ApiKeyApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        ApiKeyApi apiInstance = new ApiKeyApi();
        Integer limit = 56; // Integer | 
        Integer offset = 56; // Integer | 
        Boolean count = true; // Boolean | 
        String sort = sort_example; // String | 
        try {
            apiInstance.apiKeyGet(limit, offset, count, sort);
        } catch (ApiException e) {
            System.err.println("Exception when calling ApiKeyApi#apiKeyGet");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::ApiKeyApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::ApiKeyApi->new();
my $limit = 56; # Integer | 
my $offset = 56; # Integer | 
my $count = true; # Boolean | 
my $sort = sort_example; # String | 

eval { 
    $api_instance->apiKeyGet(limit => $limit, offset => $offset, count => $count, sort => $sort);
};
if ($@) {
    warn "Exception when calling ApiKeyApi->apiKeyGet: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.ApiKeyApi()
limit = 56 # Integer |  (optional)
offset = 56 # Integer |  (optional)
count = true # Boolean |  (optional)
sort = sort_example # String |  (optional)

try: 
    api_instance.api_key_get(limit=limit, offset=offset, count=count, sort=sort)
except ApiException as e:
    print("Exception when calling ApiKeyApi->apiKeyGet: %s\n" % e)

Parameters

Query parameters
Name Description
limit
Integer
offset
Integer
count
Boolean
sort
String

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


apiKeyIdIdDelete

Delete API Key `id`.


/api_key/id/{id}

Usage and SDK Samples

curl -X DELETE -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/api_key/id/{id}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.ApiKeyApi;

import java.io.File;
import java.util.*;

public class ApiKeyApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        ApiKeyApi apiInstance = new ApiKeyApi();
        Integer id = 56; // Integer | 
        try {
            apiInstance.apiKeyIdIdDelete(id);
        } catch (ApiException e) {
            System.err.println("Exception when calling ApiKeyApi#apiKeyIdIdDelete");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::ApiKeyApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::ApiKeyApi->new();
my $id = 56; # Integer | 

eval { 
    $api_instance->apiKeyIdIdDelete(id => $id);
};
if ($@) {
    warn "Exception when calling ApiKeyApi->apiKeyIdIdDelete: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.ApiKeyApi()
id = 56 # Integer | 

try: 
    api_instance.api_key_id_id_delete(id)
except ApiException as e:
    print("Exception when calling ApiKeyApi->apiKeyIdIdDelete: %s\n" % e)

Parameters

Path parameters
Name Description
id*
Integer
Required

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


apiKeyIdIdGet


/api_key/id/{id}

Usage and SDK Samples

curl -X GET -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/api_key/id/{id}?limit=&offset=&count=&sort="
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.ApiKeyApi;

import java.io.File;
import java.util.*;

public class ApiKeyApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        ApiKeyApi apiInstance = new ApiKeyApi();
        array[null] id = ; // array[null] | 
        Integer limit = 56; // Integer | 
        Integer offset = 56; // Integer | 
        Boolean count = true; // Boolean | 
        String sort = sort_example; // String | 
        try {
            apiInstance.apiKeyIdIdGet(id, limit, offset, count, sort);
        } catch (ApiException e) {
            System.err.println("Exception when calling ApiKeyApi#apiKeyIdIdGet");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::ApiKeyApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::ApiKeyApi->new();
my $id = []; # array[null] | 
my $limit = 56; # Integer | 
my $offset = 56; # Integer | 
my $count = true; # Boolean | 
my $sort = sort_example; # String | 

eval { 
    $api_instance->apiKeyIdIdGet(id => $id, limit => $limit, offset => $offset, count => $count, sort => $sort);
};
if ($@) {
    warn "Exception when calling ApiKeyApi->apiKeyIdIdGet: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.ApiKeyApi()
id =  # array[null] | 
limit = 56 # Integer |  (optional)
offset = 56 # Integer |  (optional)
count = true # Boolean |  (optional)
sort = sort_example # String |  (optional)

try: 
    api_instance.api_key_id_id_get(id, limit=limit, offset=offset, count=count, sort=sort)
except ApiException as e:
    print("Exception when calling ApiKeyApi->apiKeyIdIdGet: %s\n" % e)

Parameters

Path parameters
Name Description
id*
array[null]
Required
Query parameters
Name Description
limit
Integer
offset
Integer
count
Boolean
sort
String

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


apiKeyIdIdPut

Update API Key `id`. Specify `reset: true` to reset this API Key.


/api_key/id/{id}

Usage and SDK Samples

curl -X PUT -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/api_key/id/{id}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.ApiKeyApi;

import java.io.File;
import java.util.*;

public class ApiKeyApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        ApiKeyApi apiInstance = new ApiKeyApi();
        Integer id = 56; // Integer | 
        Api_key_update_1 body = ; // Api_key_update_1 | 
        try {
            apiInstance.apiKeyIdIdPut(id, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling ApiKeyApi#apiKeyIdIdPut");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::ApiKeyApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::ApiKeyApi->new();
my $id = 56; # Integer | 
my $body = WWW::SwaggerClient::Object::Api_key_update_1->new(); # Api_key_update_1 | 

eval { 
    $api_instance->apiKeyIdIdPut(id => $id, body => $body);
};
if ($@) {
    warn "Exception when calling ApiKeyApi->apiKeyIdIdPut: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.ApiKeyApi()
id = 56 # Integer | 
body =  # Api_key_update_1 |  (optional)

try: 
    api_instance.api_key_id_id_put(id, body=body)
except ApiException as e:
    print("Exception when calling ApiKeyApi->apiKeyIdIdPut: %s\n" % e)

Parameters

Path parameters
Name Description
id*
Integer
Required
Body parameters
Name Description
body

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


apiKeyPost

Creates API Key. `name` is a user-readable name for key.


/api_key

Usage and SDK Samples

curl -X POST -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/api_key"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.ApiKeyApi;

import java.io.File;
import java.util.*;

public class ApiKeyApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        ApiKeyApi apiInstance = new ApiKeyApi();
        Api_key_create_0 body = ; // Api_key_create_0 | 
        try {
            apiInstance.apiKeyPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling ApiKeyApi#apiKeyPost");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::ApiKeyApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::ApiKeyApi->new();
my $body = WWW::SwaggerClient::Object::Api_key_create_0->new(); # Api_key_create_0 | 

eval { 
    $api_instance->apiKeyPost(body => $body);
};
if ($@) {
    warn "Exception when calling ApiKeyApi->apiKeyPost: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.ApiKeyApi()
body =  # Api_key_create_0 |  (optional)

try: 
    api_instance.api_key_post(body=body)
except ApiException as e:
    print("Exception when calling ApiKeyApi->apiKeyPost: %s\n" % e)

Parameters

Body parameters
Name Description
body

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


Auth

authCheckUserPost

Verify username and password


/auth/check_user

Usage and SDK Samples

curl -X POST -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/auth/check_user"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.AuthApi;

import java.io.File;
import java.util.*;

public class AuthApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        AuthApi apiInstance = new AuthApi();
        Auth_check_user body = ; // Auth_check_user | 
        try {
            apiInstance.authCheckUserPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling AuthApi#authCheckUserPost");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::AuthApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::AuthApi->new();
my $body = WWW::SwaggerClient::Object::Auth_check_user->new(); # Auth_check_user | 

eval { 
    $api_instance->authCheckUserPost(body => $body);
};
if ($@) {
    warn "Exception when calling AuthApi->authCheckUserPost: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.AuthApi()
body =  # Auth_check_user |  (optional)

try: 
    api_instance.auth_check_user_post(body=body)
except ApiException as e:
    print("Exception when calling AuthApi->authCheckUserPost: %s\n" % e)

Parameters

Body parameters
Name Description
body

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


authGenerateTokenPost

Generate a token to be used for authentication. `ttl` stands for Time To Live, in seconds. The token will be invalidated if the connection has been inactive for a time greater than this. `attrs` is a general purpose object/dictionary to hold information about the token.


/auth/generate_token

Usage and SDK Samples

curl -X POST -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/auth/generate_token"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.AuthApi;

import java.io.File;
import java.util.*;

public class AuthApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        AuthApi apiInstance = new AuthApi();
        Auth_generate_token body = ; // Auth_generate_token | 
        try {
            apiInstance.authGenerateTokenPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling AuthApi#authGenerateTokenPost");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::AuthApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::AuthApi->new();
my $body = WWW::SwaggerClient::Object::Auth_generate_token->new(); # Auth_generate_token | 

eval { 
    $api_instance->authGenerateTokenPost(body => $body);
};
if ($@) {
    warn "Exception when calling AuthApi->authGenerateTokenPost: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.AuthApi()
body =  # Auth_generate_token |  (optional)

try: 
    api_instance.auth_generate_token_post(body=body)
except ApiException as e:
    print("Exception when calling AuthApi->authGenerateTokenPost: %s\n" % e)

Parameters

Body parameters
Name Description
body

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


authSessionsGet

Returns list of active auth sessions. Example of return value: [ { "id": "NyhB1J5vjPjIV82yZ6caU12HLA1boDJcZNWuVQM4hQWuiyUWMGZTz2ElDp7Yk87d", "origin": "192.168.0.3:40392", "credentials": "TOKEN", "internal": False, "created_at": {"$date": 1545842426070} } ] `credentials` can be `UNIX_SOCKET`, `ROOT_TCP_SOCKET`, `TRUENAS_NODE`, `LOGIN_PASSWORD` or `TOKEN`, depending on what authentication method was used. If you want to exclude all internal connections from the list, call this method with following arguments: [ [ ["internal", "=", True] ] ]


/auth/sessions

Usage and SDK Samples

curl -X GET -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/auth/sessions?limit=&offset=&count=&sort="
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.AuthApi;

import java.io.File;
import java.util.*;

public class AuthApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        AuthApi apiInstance = new AuthApi();
        Integer limit = 56; // Integer | 
        Integer offset = 56; // Integer | 
        Boolean count = true; // Boolean | 
        String sort = sort_example; // String | 
        try {
            apiInstance.authSessionsGet(limit, offset, count, sort);
        } catch (ApiException e) {
            System.err.println("Exception when calling AuthApi#authSessionsGet");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::AuthApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::AuthApi->new();
my $limit = 56; # Integer | 
my $offset = 56; # Integer | 
my $count = true; # Boolean | 
my $sort = sort_example; # String | 

eval { 
    $api_instance->authSessionsGet(limit => $limit, offset => $offset, count => $count, sort => $sort);
};
if ($@) {
    warn "Exception when calling AuthApi->authSessionsGet: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.AuthApi()
limit = 56 # Integer |  (optional)
offset = 56 # Integer |  (optional)
count = true # Boolean |  (optional)
sort = sort_example # String |  (optional)

try: 
    api_instance.auth_sessions_get(limit=limit, offset=offset, count=count, sort=sort)
except ApiException as e:
    print("Exception when calling AuthApi->authSessionsGet: %s\n" % e)

Parameters

Query parameters
Name Description
limit
Integer
offset
Integer
count
Boolean
sort
String

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


authTwoFactorAuthGet

Returns true if two factor authorization is required for authorizing user's login.


/auth/two_factor_auth

Usage and SDK Samples

curl -X GET -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/auth/two_factor_auth"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.AuthApi;

import java.io.File;
import java.util.*;

public class AuthApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        AuthApi apiInstance = new AuthApi();
        try {
            apiInstance.authTwoFactorAuthGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling AuthApi#authTwoFactorAuthGet");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::AuthApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::AuthApi->new();

eval { 
    $api_instance->authTwoFactorAuthGet();
};
if ($@) {
    warn "Exception when calling AuthApi->authTwoFactorAuthGet: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.AuthApi()

try: 
    api_instance.auth_two_factor_auth_get()
except ApiException as e:
    print("Exception when calling AuthApi->authTwoFactorAuthGet: %s\n" % e)

Parameters

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


AuthTwofactor

authTwofactorGet


/auth/twofactor

Usage and SDK Samples

curl -X GET -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/auth/twofactor"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.AuthTwofactorApi;

import java.io.File;
import java.util.*;

public class AuthTwofactorApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        AuthTwofactorApi apiInstance = new AuthTwofactorApi();
        try {
            apiInstance.authTwofactorGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling AuthTwofactorApi#authTwofactorGet");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::AuthTwofactorApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::AuthTwofactorApi->new();

eval { 
    $api_instance->authTwofactorGet();
};
if ($@) {
    warn "Exception when calling AuthTwofactorApi->authTwofactorGet: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.AuthTwofactorApi()

try: 
    api_instance.auth_twofactor_get()
except ApiException as e:
    print("Exception when calling AuthTwofactorApi->authTwofactorGet: %s\n" % e)

Parameters

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


authTwofactorProvisioningUriGet

Returns the provisioning URI for the OTP. This can then be encoded in a QR Code and used to provision an OTP app like Google Authenticator.


/auth/twofactor/provisioning_uri

Usage and SDK Samples

curl -X GET -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/auth/twofactor/provisioning_uri"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.AuthTwofactorApi;

import java.io.File;
import java.util.*;

public class AuthTwofactorApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        AuthTwofactorApi apiInstance = new AuthTwofactorApi();
        try {
            apiInstance.authTwofactorProvisioningUriGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling AuthTwofactorApi#authTwofactorProvisioningUriGet");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::AuthTwofactorApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::AuthTwofactorApi->new();

eval { 
    $api_instance->authTwofactorProvisioningUriGet();
};
if ($@) {
    warn "Exception when calling AuthTwofactorApi->authTwofactorProvisioningUriGet: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.AuthTwofactorApi()

try: 
    api_instance.auth_twofactor_provisioning_uri_get()
except ApiException as e:
    print("Exception when calling AuthTwofactorApi->authTwofactorProvisioningUriGet: %s\n" % e)

Parameters

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


authTwofactorPut

`otp_digits` represents number of allowed digits in the OTP. `window` extends the validity to `window` many counter ticks before and after the current one. `interval` is time duration in seconds specifying OTP expiration time from it's creation time.


/auth/twofactor

Usage and SDK Samples

curl -X PUT -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/auth/twofactor"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.AuthTwofactorApi;

import java.io.File;
import java.util.*;

public class AuthTwofactorApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        AuthTwofactorApi apiInstance = new AuthTwofactorApi();
        Auth_twofactor_update_0 body = ; // Auth_twofactor_update_0 | 
        try {
            apiInstance.authTwofactorPut(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling AuthTwofactorApi#authTwofactorPut");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::AuthTwofactorApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::AuthTwofactorApi->new();
my $body = WWW::SwaggerClient::Object::Auth_twofactor_update_0->new(); # Auth_twofactor_update_0 | 

eval { 
    $api_instance->authTwofactorPut(body => $body);
};
if ($@) {
    warn "Exception when calling AuthTwofactorApi->authTwofactorPut: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.AuthTwofactorApi()
body =  # Auth_twofactor_update_0 |  (optional)

try: 
    api_instance.auth_twofactor_put(body=body)
except ApiException as e:
    print("Exception when calling AuthTwofactorApi->authTwofactorPut: %s\n" % e)

Parameters

Body parameters
Name Description
body

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


authTwofactorRenewSecretGet

Generates a new secret for Two Factor Authentication. Returns boolean true on success.


/auth/twofactor/renew_secret

Usage and SDK Samples

curl -X GET -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/auth/twofactor/renew_secret"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.AuthTwofactorApi;

import java.io.File;
import java.util.*;

public class AuthTwofactorApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        AuthTwofactorApi apiInstance = new AuthTwofactorApi();
        try {
            apiInstance.authTwofactorRenewSecretGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling AuthTwofactorApi#authTwofactorRenewSecretGet");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::AuthTwofactorApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::AuthTwofactorApi->new();

eval { 
    $api_instance->authTwofactorRenewSecretGet();
};
if ($@) {
    warn "Exception when calling AuthTwofactorApi->authTwofactorRenewSecretGet: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.AuthTwofactorApi()

try: 
    api_instance.auth_twofactor_renew_secret_get()
except ApiException as e:
    print("Exception when calling AuthTwofactorApi->authTwofactorRenewSecretGet: %s\n" % e)

Parameters

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


authTwofactorVerifyPost

Returns boolean true if provided `token` is successfully authenticated.


/auth/twofactor/verify

Usage and SDK Samples

curl -X POST -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/auth/twofactor/verify"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.AuthTwofactorApi;

import java.io.File;
import java.util.*;

public class AuthTwofactorApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        AuthTwofactorApi apiInstance = new AuthTwofactorApi();
        String body = ; // String | 
        try {
            apiInstance.authTwofactorVerifyPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling AuthTwofactorApi#authTwofactorVerifyPost");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::AuthTwofactorApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::AuthTwofactorApi->new();
my $body = WWW::SwaggerClient::Object::String->new(); # String | 

eval { 
    $api_instance->authTwofactorVerifyPost(body => $body);
};
if ($@) {
    warn "Exception when calling AuthTwofactorApi->authTwofactorVerifyPost: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.AuthTwofactorApi()
body =  # String |  (optional)

try: 
    api_instance.auth_twofactor_verify_post(body=body)
except ApiException as e:
    print("Exception when calling AuthTwofactorApi->authTwofactorVerifyPost: %s\n" % e)

Parameters

Body parameters
Name Description
body

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


Boot

bootAttachPost

Attach a disk to the boot pool, turning a stripe into a mirror. `expand` option will determine whether the new disk partition will be the maximum available or the same size as the current disk.


/boot/attach

Usage and SDK Samples

curl -X POST -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/boot/attach"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.BootApi;

import java.io.File;
import java.util.*;

public class BootApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        BootApi apiInstance = new BootApi();
        Boot_attach body = ; // Boot_attach | 
        try {
            apiInstance.bootAttachPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling BootApi#bootAttachPost");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::BootApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::BootApi->new();
my $body = WWW::SwaggerClient::Object::Boot_attach->new(); # Boot_attach | 

eval { 
    $api_instance->bootAttachPost(body => $body);
};
if ($@) {
    warn "Exception when calling BootApi->bootAttachPost: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.BootApi()
body =  # Boot_attach |  (optional)

try: 
    api_instance.boot_attach_post(body=body)
except ApiException as e:
    print("Exception when calling BootApi->bootAttachPost: %s\n" % e)

Parameters

Body parameters
Name Description
body

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


bootDetachPost

Detach given `dev` from boot pool.


/boot/detach

Usage and SDK Samples

curl -X POST -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/boot/detach"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.BootApi;

import java.io.File;
import java.util.*;

public class BootApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        BootApi apiInstance = new BootApi();
        String body = ; // String | 
        try {
            apiInstance.bootDetachPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling BootApi#bootDetachPost");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::BootApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::BootApi->new();
my $body = WWW::SwaggerClient::Object::String->new(); # String | 

eval { 
    $api_instance->bootDetachPost(body => $body);
};
if ($@) {
    warn "Exception when calling BootApi->bootDetachPost: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.BootApi()
body =  # String |  (optional)

try: 
    api_instance.boot_detach_post(body=body)
except ApiException as e:
    print("Exception when calling BootApi->bootDetachPost: %s\n" % e)

Parameters

Body parameters
Name Description
body

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


bootGetDisksGet

Returns disks of the boot pool.


/boot/get_disks

Usage and SDK Samples

curl -X GET -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/boot/get_disks"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.BootApi;

import java.io.File;
import java.util.*;

public class BootApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        BootApi apiInstance = new BootApi();
        try {
            apiInstance.bootGetDisksGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling BootApi#bootGetDisksGet");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::BootApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::BootApi->new();

eval { 
    $api_instance->bootGetDisksGet();
};
if ($@) {
    warn "Exception when calling BootApi->bootGetDisksGet: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.BootApi()

try: 
    api_instance.boot_get_disks_get()
except ApiException as e:
    print("Exception when calling BootApi->bootGetDisksGet: %s\n" % e)

Parameters

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


bootGetScrubIntervalGet

Get Automatic Scrub Interval value in days.


/boot/get_scrub_interval

Usage and SDK Samples

curl -X GET -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/boot/get_scrub_interval"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.BootApi;

import java.io.File;
import java.util.*;

public class BootApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        BootApi apiInstance = new BootApi();
        try {
            apiInstance.bootGetScrubIntervalGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling BootApi#bootGetScrubIntervalGet");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::BootApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::BootApi->new();

eval { 
    $api_instance->bootGetScrubIntervalGet();
};
if ($@) {
    warn "Exception when calling BootApi->bootGetScrubIntervalGet: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.BootApi()

try: 
    api_instance.boot_get_scrub_interval_get()
except ApiException as e:
    print("Exception when calling BootApi->bootGetScrubIntervalGet: %s\n" % e)

Parameters

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


bootGetStateGet

Returns the current state of the boot pool, including all vdevs, properties and datasets.


/boot/get_state

Usage and SDK Samples

curl -X GET -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/boot/get_state"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.BootApi;

import java.io.File;
import java.util.*;

public class BootApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        BootApi apiInstance = new BootApi();
        try {
            apiInstance.bootGetStateGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling BootApi#bootGetStateGet");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::BootApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::BootApi->new();

eval { 
    $api_instance->bootGetStateGet();
};
if ($@) {
    warn "Exception when calling BootApi->bootGetStateGet: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.BootApi()

try: 
    api_instance.boot_get_state_get()
except ApiException as e:
    print("Exception when calling BootApi->bootGetStateGet: %s\n" % e)

Parameters

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


bootReplacePost

Replace device `label` on boot pool with `dev`.


/boot/replace

Usage and SDK Samples

curl -X POST -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/boot/replace"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.BootApi;

import java.io.File;
import java.util.*;

public class BootApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        BootApi apiInstance = new BootApi();
        Boot_replace body = ; // Boot_replace | 
        try {
            apiInstance.bootReplacePost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling BootApi#bootReplacePost");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::BootApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::BootApi->new();
my $body = WWW::SwaggerClient::Object::Boot_replace->new(); # Boot_replace | 

eval { 
    $api_instance->bootReplacePost(body => $body);
};
if ($@) {
    warn "Exception when calling BootApi->bootReplacePost: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.BootApi()
body =  # Boot_replace |  (optional)

try: 
    api_instance.boot_replace_post(body=body)
except ApiException as e:
    print("Exception when calling BootApi->bootReplacePost: %s\n" % e)

Parameters

Body parameters
Name Description
body

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


bootScrubGet

Scrub on boot pool.


/boot/scrub

Usage and SDK Samples

curl -X GET -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/boot/scrub"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.BootApi;

import java.io.File;
import java.util.*;

public class BootApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        BootApi apiInstance = new BootApi();
        try {
            apiInstance.bootScrubGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling BootApi#bootScrubGet");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::BootApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::BootApi->new();

eval { 
    $api_instance->bootScrubGet();
};
if ($@) {
    warn "Exception when calling BootApi->bootScrubGet: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.BootApi()

try: 
    api_instance.boot_scrub_get()
except ApiException as e:
    print("Exception when calling BootApi->bootScrubGet: %s\n" % e)

Parameters

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


bootSetScrubIntervalPost

Set Automatic Scrub Interval value in days.


/boot/set_scrub_interval

Usage and SDK Samples

curl -X POST -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/boot/set_scrub_interval"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.BootApi;

import java.io.File;
import java.util.*;

public class BootApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        BootApi apiInstance = new BootApi();
        Integer body = ; // Integer | 
        try {
            apiInstance.bootSetScrubIntervalPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling BootApi#bootSetScrubIntervalPost");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::BootApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::BootApi->new();
my $body = WWW::SwaggerClient::Object::Integer->new(); # Integer | 

eval { 
    $api_instance->bootSetScrubIntervalPost(body => $body);
};
if ($@) {
    warn "Exception when calling BootApi->bootSetScrubIntervalPost: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.BootApi()
body =  # Integer |  (optional)

try: 
    api_instance.boot_set_scrub_interval_post(body=body)
except ApiException as e:
    print("Exception when calling BootApi->bootSetScrubIntervalPost: %s\n" % e)

Parameters

Body parameters
Name Description
body

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


Bootenv

bootenvGet

Query all Boot Environments with `query-filters` and `query-options`.


/bootenv

Usage and SDK Samples

curl -X GET -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/bootenv?limit=&offset=&count=&sort="
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.BootenvApi;

import java.io.File;
import java.util.*;

public class BootenvApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        BootenvApi apiInstance = new BootenvApi();
        Integer limit = 56; // Integer | 
        Integer offset = 56; // Integer | 
        Boolean count = true; // Boolean | 
        String sort = sort_example; // String | 
        try {
            apiInstance.bootenvGet(limit, offset, count, sort);
        } catch (ApiException e) {
            System.err.println("Exception when calling BootenvApi#bootenvGet");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::BootenvApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::BootenvApi->new();
my $limit = 56; # Integer | 
my $offset = 56; # Integer | 
my $count = true; # Boolean | 
my $sort = sort_example; # String | 

eval { 
    $api_instance->bootenvGet(limit => $limit, offset => $offset, count => $count, sort => $sort);
};
if ($@) {
    warn "Exception when calling BootenvApi->bootenvGet: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.BootenvApi()
limit = 56 # Integer |  (optional)
offset = 56 # Integer |  (optional)
count = true # Boolean |  (optional)
sort = sort_example # String |  (optional)

try: 
    api_instance.bootenv_get(limit=limit, offset=offset, count=count, sort=sort)
except ApiException as e:
    print("Exception when calling BootenvApi->bootenvGet: %s\n" % e)

Parameters

Query parameters
Name Description
limit
Integer
offset
Integer
count
Boolean
sort
String

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


bootenvIdIdActivatePost

Activates boot environment `id`.


/bootenv/id/{id}/activate

Usage and SDK Samples

curl -X POST -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/bootenv/id/{id}/activate"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.BootenvApi;

import java.io.File;
import java.util.*;

public class BootenvApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        BootenvApi apiInstance = new BootenvApi();
        String id = id_example; // String | 
        Bootenv_activate body = ; // Bootenv_activate | 
        try {
            apiInstance.bootenvIdIdActivatePost(id, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling BootenvApi#bootenvIdIdActivatePost");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::BootenvApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::BootenvApi->new();
my $id = id_example; # String | 
my $body = WWW::SwaggerClient::Object::Bootenv_activate->new(); # Bootenv_activate | 

eval { 
    $api_instance->bootenvIdIdActivatePost(id => $id, body => $body);
};
if ($@) {
    warn "Exception when calling BootenvApi->bootenvIdIdActivatePost: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.BootenvApi()
id = id_example # String | 
body =  # Bootenv_activate |  (optional)

try: 
    api_instance.bootenv_id_id_activate_post(id, body=body)
except ApiException as e:
    print("Exception when calling BootenvApi->bootenvIdIdActivatePost: %s\n" % e)

Parameters

Path parameters
Name Description
id*
String
Required
Body parameters
Name Description
body

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


bootenvIdIdDelete

Delete `id` boot environment. This removes the clone from the system.


/bootenv/id/{id}

Usage and SDK Samples

curl -X DELETE -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/bootenv/id/{id}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.BootenvApi;

import java.io.File;
import java.util.*;

public class BootenvApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        BootenvApi apiInstance = new BootenvApi();
        String id = id_example; // String | 
        try {
            apiInstance.bootenvIdIdDelete(id);
        } catch (ApiException e) {
            System.err.println("Exception when calling BootenvApi#bootenvIdIdDelete");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::BootenvApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::BootenvApi->new();
my $id = id_example; # String | 

eval { 
    $api_instance->bootenvIdIdDelete(id => $id);
};
if ($@) {
    warn "Exception when calling BootenvApi->bootenvIdIdDelete: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.BootenvApi()
id = id_example # String | 

try: 
    api_instance.bootenv_id_id_delete(id)
except ApiException as e:
    print("Exception when calling BootenvApi->bootenvIdIdDelete: %s\n" % e)

Parameters

Path parameters
Name Description
id*
String
Required

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


bootenvIdIdGet

Query all Boot Environments with `query-filters` and `query-options`.


/bootenv/id/{id}

Usage and SDK Samples

curl -X GET -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/bootenv/id/{id}?limit=&offset=&count=&sort="
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.BootenvApi;

import java.io.File;
import java.util.*;

public class BootenvApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        BootenvApi apiInstance = new BootenvApi();
        array[null] id = ; // array[null] | 
        Integer limit = 56; // Integer | 
        Integer offset = 56; // Integer | 
        Boolean count = true; // Boolean | 
        String sort = sort_example; // String | 
        try {
            apiInstance.bootenvIdIdGet(id, limit, offset, count, sort);
        } catch (ApiException e) {
            System.err.println("Exception when calling BootenvApi#bootenvIdIdGet");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::BootenvApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::BootenvApi->new();
my $id = []; # array[null] | 
my $limit = 56; # Integer | 
my $offset = 56; # Integer | 
my $count = true; # Boolean | 
my $sort = sort_example; # String | 

eval { 
    $api_instance->bootenvIdIdGet(id => $id, limit => $limit, offset => $offset, count => $count, sort => $sort);
};
if ($@) {
    warn "Exception when calling BootenvApi->bootenvIdIdGet: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.BootenvApi()
id =  # array[null] | 
limit = 56 # Integer |  (optional)
offset = 56 # Integer |  (optional)
count = true # Boolean |  (optional)
sort = sort_example # String |  (optional)

try: 
    api_instance.bootenv_id_id_get(id, limit=limit, offset=offset, count=count, sort=sort)
except ApiException as e:
    print("Exception when calling BootenvApi->bootenvIdIdGet: %s\n" % e)

Parameters

Path parameters
Name Description
id*
array[null]
Required
Query parameters
Name Description
limit
Integer
offset
Integer
count
Boolean
sort
String

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


bootenvIdIdPut

Update `id` boot environment name with a new provided valid `name`.


/bootenv/id/{id}

Usage and SDK Samples

curl -X PUT -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/bootenv/id/{id}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.BootenvApi;

import java.io.File;
import java.util.*;

public class BootenvApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        BootenvApi apiInstance = new BootenvApi();
        String id = id_example; // String | 
        Bootenv_update_1 body = ; // Bootenv_update_1 | 
        try {
            apiInstance.bootenvIdIdPut(id, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling BootenvApi#bootenvIdIdPut");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::BootenvApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::BootenvApi->new();
my $id = id_example; # String | 
my $body = WWW::SwaggerClient::Object::Bootenv_update_1->new(); # Bootenv_update_1 | 

eval { 
    $api_instance->bootenvIdIdPut(id => $id, body => $body);
};
if ($@) {
    warn "Exception when calling BootenvApi->bootenvIdIdPut: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.BootenvApi()
id = id_example # String | 
body =  # Bootenv_update_1 |  (optional)

try: 
    api_instance.bootenv_id_id_put(id, body=body)
except ApiException as e:
    print("Exception when calling BootenvApi->bootenvIdIdPut: %s\n" % e)

Parameters

Path parameters
Name Description
id*
String
Required
Body parameters
Name Description
body

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


bootenvIdIdSetAttributePost

Sets attributes boot environment `id`. Currently only `keep` attribute is allowed.


/bootenv/id/{id}/set_attribute

Usage and SDK Samples

curl -X POST -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/bootenv/id/{id}/set_attribute"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.BootenvApi;

import java.io.File;
import java.util.*;

public class BootenvApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        BootenvApi apiInstance = new BootenvApi();
        String id = id_example; // String | 
        Bootenv_set_attribute_1 body = ; // Bootenv_set_attribute_1 | 
        try {
            apiInstance.bootenvIdIdSetAttributePost(id, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling BootenvApi#bootenvIdIdSetAttributePost");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::BootenvApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::BootenvApi->new();
my $id = id_example; # String | 
my $body = WWW::SwaggerClient::Object::Bootenv_set_attribute_1->new(); # Bootenv_set_attribute_1 | 

eval { 
    $api_instance->bootenvIdIdSetAttributePost(id => $id, body => $body);
};
if ($@) {
    warn "Exception when calling BootenvApi->bootenvIdIdSetAttributePost: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.BootenvApi()
id = id_example # String | 
body =  # Bootenv_set_attribute_1 |  (optional)

try: 
    api_instance.bootenv_id_id_set_attribute_post(id, body=body)
except ApiException as e:
    print("Exception when calling BootenvApi->bootenvIdIdSetAttributePost: %s\n" % e)

Parameters

Path parameters
Name Description
id*
String
Required
Body parameters
Name Description
body

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


bootenvPost

Create a new boot environment using `name`. If a new boot environment is desired which is a clone of another boot environment, `source` can be passed. Then, a new boot environment of `name` is created using boot environment `source` by cloning it. Ensure that `name` and `source` are valid boot environment names.


/bootenv

Usage and SDK Samples

curl -X POST -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/bootenv"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.BootenvApi;

import java.io.File;
import java.util.*;

public class BootenvApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        BootenvApi apiInstance = new BootenvApi();
        Bootenv_create_0 body = ; // Bootenv_create_0 | 
        try {
            apiInstance.bootenvPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling BootenvApi#bootenvPost");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::BootenvApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::BootenvApi->new();
my $body = WWW::SwaggerClient::Object::Bootenv_create_0->new(); # Bootenv_create_0 | 

eval { 
    $api_instance->bootenvPost(body => $body);
};
if ($@) {
    warn "Exception when calling BootenvApi->bootenvPost: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.BootenvApi()
body =  # Bootenv_create_0 |  (optional)

try: 
    api_instance.bootenv_post(body=body)
except ApiException as e:
    print("Exception when calling BootenvApi->bootenvPost: %s\n" % e)

Parameters

Body parameters
Name Description
body

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


Certificate

certificateAcmeServerChoicesGet

Dictionary of popular ACME Servers with their directory URI endpoints which we display automatically in UI


/certificate/acme_server_choices

Usage and SDK Samples

curl -X GET -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/certificate/acme_server_choices"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.CertificateApi;

import java.io.File;
import java.util.*;

public class CertificateApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        CertificateApi apiInstance = new CertificateApi();
        try {
            apiInstance.certificateAcmeServerChoicesGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling CertificateApi#certificateAcmeServerChoicesGet");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::CertificateApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::CertificateApi->new();

eval { 
    $api_instance->certificateAcmeServerChoicesGet();
};
if ($@) {
    warn "Exception when calling CertificateApi->certificateAcmeServerChoicesGet: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.CertificateApi()

try: 
    api_instance.certificate_acme_server_choices_get()
except ApiException as e:
    print("Exception when calling CertificateApi->certificateAcmeServerChoicesGet: %s\n" % e)

Parameters

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


certificateCountryChoicesGet

Returns country choices for creating a certificate/csr.


/certificate/country_choices

Usage and SDK Samples

curl -X GET -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/certificate/country_choices"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.CertificateApi;

import java.io.File;
import java.util.*;

public class CertificateApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        CertificateApi apiInstance = new CertificateApi();
        try {
            apiInstance.certificateCountryChoicesGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling CertificateApi#certificateCountryChoicesGet");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::CertificateApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::CertificateApi->new();

eval { 
    $api_instance->certificateCountryChoicesGet();
};
if ($@) {
    warn "Exception when calling CertificateApi->certificateCountryChoicesGet: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.CertificateApi()

try: 
    api_instance.certificate_country_choices_get()
except ApiException as e:
    print("Exception when calling CertificateApi->certificateCountryChoicesGet: %s\n" % e)

Parameters

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


certificateEcCurveChoicesGet

Dictionary of supported EC curves.


/certificate/ec_curve_choices

Usage and SDK Samples

curl -X GET -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/certificate/ec_curve_choices"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.CertificateApi;

import java.io.File;
import java.util.*;

public class CertificateApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        CertificateApi apiInstance = new CertificateApi();
        try {
            apiInstance.certificateEcCurveChoicesGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling CertificateApi#certificateEcCurveChoicesGet");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::CertificateApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::CertificateApi->new();

eval { 
    $api_instance->certificateEcCurveChoicesGet();
};
if ($@) {
    warn "Exception when calling CertificateApi->certificateEcCurveChoicesGet: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.CertificateApi()

try: 
    api_instance.certificate_ec_curve_choices_get()
except ApiException as e:
    print("Exception when calling CertificateApi->certificateEcCurveChoicesGet: %s\n" % e)

Parameters

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


certificateExtendedKeyUsageChoicesGet

Dictionary of choices for `ExtendedKeyUsage` extension which can be passed over to `usages` attribute.


/certificate/extended_key_usage_choices

Usage and SDK Samples

curl -X GET -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/certificate/extended_key_usage_choices"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.CertificateApi;

import java.io.File;
import java.util.*;

public class CertificateApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        CertificateApi apiInstance = new CertificateApi();
        try {
            apiInstance.certificateExtendedKeyUsageChoicesGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling CertificateApi#certificateExtendedKeyUsageChoicesGet");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::CertificateApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::CertificateApi->new();

eval { 
    $api_instance->certificateExtendedKeyUsageChoicesGet();
};
if ($@) {
    warn "Exception when calling CertificateApi->certificateExtendedKeyUsageChoicesGet: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.CertificateApi()

try: 
    api_instance.certificate_extended_key_usage_choices_get()
except ApiException as e:
    print("Exception when calling CertificateApi->certificateExtendedKeyUsageChoicesGet: %s\n" % e)

Parameters

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


certificateGet


/certificate

Usage and SDK Samples

curl -X GET -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/certificate?limit=&offset=&count=&sort="
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.CertificateApi;

import java.io.File;
import java.util.*;

public class CertificateApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        CertificateApi apiInstance = new CertificateApi();
        Integer limit = 56; // Integer | 
        Integer offset = 56; // Integer | 
        Boolean count = true; // Boolean | 
        String sort = sort_example; // String | 
        try {
            apiInstance.certificateGet(limit, offset, count, sort);
        } catch (ApiException e) {
            System.err.println("Exception when calling CertificateApi#certificateGet");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::CertificateApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::CertificateApi->new();
my $limit = 56; # Integer | 
my $offset = 56; # Integer | 
my $count = true; # Boolean | 
my $sort = sort_example; # String | 

eval { 
    $api_instance->certificateGet(limit => $limit, offset => $offset, count => $count, sort => $sort);
};
if ($@) {
    warn "Exception when calling CertificateApi->certificateGet: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.CertificateApi()
limit = 56 # Integer |  (optional)
offset = 56 # Integer |  (optional)
count = true # Boolean |  (optional)
sort = sort_example # String |  (optional)

try: 
    api_instance.certificate_get(limit=limit, offset=offset, count=count, sort=sort)
except ApiException as e:
    print("Exception when calling CertificateApi->certificateGet: %s\n" % e)

Parameters

Query parameters
Name Description
limit
Integer
offset
Integer
count
Boolean
sort
String

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


certificateIdIdDelete

Delete certificate of `id`. If the certificate is an ACME based certificate, certificate service will try to revoke the certificate by updating it's status with the ACME server, if it fails an exception is raised and the certificate is not deleted from the system. However, if `force` is set to True, certificate is deleted from the system even if some error occurred while revoking the certificate with the ACME Server


/certificate/id/{id}

Usage and SDK Samples

curl -X DELETE -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/certificate/id/{id}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.CertificateApi;

import java.io.File;
import java.util.*;

public class CertificateApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        CertificateApi apiInstance = new CertificateApi();
        Integer id = 56; // Integer | 
        Boolean body = ; // Boolean | 
        try {
            apiInstance.certificateIdIdDelete(id, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling CertificateApi#certificateIdIdDelete");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::CertificateApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::CertificateApi->new();
my $id = 56; # Integer | 
my $body = WWW::SwaggerClient::Object::Boolean->new(); # Boolean | 

eval { 
    $api_instance->certificateIdIdDelete(id => $id, body => $body);
};
if ($@) {
    warn "Exception when calling CertificateApi->certificateIdIdDelete: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.CertificateApi()
id = 56 # Integer | 
body =  # Boolean |  (optional)

try: 
    api_instance.certificate_id_id_delete(id, body=body)
except ApiException as e:
    print("Exception when calling CertificateApi->certificateIdIdDelete: %s\n" % e)

Parameters

Path parameters
Name Description
id*
Integer
Required
Body parameters
Name Description
body

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


certificateIdIdGet


/certificate/id/{id}

Usage and SDK Samples

curl -X GET -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/certificate/id/{id}?limit=&offset=&count=&sort="
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.CertificateApi;

import java.io.File;
import java.util.*;

public class CertificateApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        CertificateApi apiInstance = new CertificateApi();
        array[null] id = ; // array[null] | 
        Integer limit = 56; // Integer | 
        Integer offset = 56; // Integer | 
        Boolean count = true; // Boolean | 
        String sort = sort_example; // String | 
        try {
            apiInstance.certificateIdIdGet(id, limit, offset, count, sort);
        } catch (ApiException e) {
            System.err.println("Exception when calling CertificateApi#certificateIdIdGet");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::CertificateApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::CertificateApi->new();
my $id = []; # array[null] | 
my $limit = 56; # Integer | 
my $offset = 56; # Integer | 
my $count = true; # Boolean | 
my $sort = sort_example; # String | 

eval { 
    $api_instance->certificateIdIdGet(id => $id, limit => $limit, offset => $offset, count => $count, sort => $sort);
};
if ($@) {
    warn "Exception when calling CertificateApi->certificateIdIdGet: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.CertificateApi()
id =  # array[null] | 
limit = 56 # Integer |  (optional)
offset = 56 # Integer |  (optional)
count = true # Boolean |  (optional)
sort = sort_example # String |  (optional)

try: 
    api_instance.certificate_id_id_get(id, limit=limit, offset=offset, count=count, sort=sort)
except ApiException as e:
    print("Exception when calling CertificateApi->certificateIdIdGet: %s\n" % e)

Parameters

Path parameters
Name Description
id*
array[null]
Required
Query parameters
Name Description
limit
Integer
offset
Integer
count
Boolean
sort
String

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


certificateIdIdPut

Update certificate of `id` Only name and revoked attribute can be updated. When `revoked` is enabled, the specified cert `id` is revoked and if it belongs to a CA chain which exists on this system, its serial number is added to the CA's certificate revocation list.


/certificate/id/{id}

Usage and SDK Samples

curl -X PUT -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/certificate/id/{id}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.CertificateApi;

import java.io.File;
import java.util.*;

public class CertificateApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        CertificateApi apiInstance = new CertificateApi();
        Integer id = 56; // Integer | 
        Certificate_update_1 body = ; // Certificate_update_1 | 
        try {
            apiInstance.certificateIdIdPut(id, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling CertificateApi#certificateIdIdPut");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::CertificateApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::CertificateApi->new();
my $id = 56; # Integer | 
my $body = WWW::SwaggerClient::Object::Certificate_update_1->new(); # Certificate_update_1 | 

eval { 
    $api_instance->certificateIdIdPut(id => $id, body => $body);
};
if ($@) {
    warn "Exception when calling CertificateApi->certificateIdIdPut: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.CertificateApi()
id = 56 # Integer | 
body =  # Certificate_update_1 |  (optional)

try: 
    api_instance.certificate_id_id_put(id, body=body)
except ApiException as e:
    print("Exception when calling CertificateApi->certificateIdIdPut: %s\n" % e)

Parameters

Path parameters
Name Description
id*
Integer
Required
Body parameters
Name Description
body

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


certificateKeyTypeChoicesGet

Dictionary of supported key types for certificates.


/certificate/key_type_choices

Usage and SDK Samples

curl -X GET -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/certificate/key_type_choices"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.CertificateApi;

import java.io.File;
import java.util.*;

public class CertificateApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        CertificateApi apiInstance = new CertificateApi();
        try {
            apiInstance.certificateKeyTypeChoicesGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling CertificateApi#certificateKeyTypeChoicesGet");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::CertificateApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::CertificateApi->new();

eval { 
    $api_instance->certificateKeyTypeChoicesGet();
};
if ($@) {
    warn "Exception when calling CertificateApi->certificateKeyTypeChoicesGet: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.CertificateApi()

try: 
    api_instance.certificate_key_type_choices_get()
except ApiException as e:
    print("Exception when calling CertificateApi->certificateKeyTypeChoicesGet: %s\n" % e)

Parameters

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


certificatePost

Create a new Certificate Certificates are classified under following types and the necessary keywords to be passed for `create_type` attribute to create the respective type of certificate 1) Internal Certificate - CERTIFICATE_CREATE_INTERNAL 2) Imported Certificate - CERTIFICATE_CREATE_IMPORTED 3) Certificate Signing Request - CERTIFICATE_CREATE_CSR 4) Imported Certificate Signing Request - CERTIFICATE_CREATE_IMPORTED_CSR 5) ACME Certificate - CERTIFICATE_CREATE_ACME By default, created certs use RSA keys. If an Elliptic Curve Key is desired, it can be specified with the `key_type` attribute. If the `ec_curve` attribute is not specified for the Elliptic Curve Key, then default to using "BrainpoolP384R1" curve. A type is selected by the Certificate Service based on `create_type`. The rest of the values in `data` are validated accordingly and finally a certificate is made based on the selected type. `cert_extensions` can be specified to set X509v3 extensions.


/certificate

Usage and SDK Samples

curl -X POST -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/certificate"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.CertificateApi;

import java.io.File;
import java.util.*;

public class CertificateApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        CertificateApi apiInstance = new CertificateApi();
        Certificate_create_0 body = ; // Certificate_create_0 | 
        try {
            apiInstance.certificatePost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling CertificateApi#certificatePost");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::CertificateApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::CertificateApi->new();
my $body = WWW::SwaggerClient::Object::Certificate_create_0->new(); # Certificate_create_0 | 

eval { 
    $api_instance->certificatePost(body => $body);
};
if ($@) {
    warn "Exception when calling CertificateApi->certificatePost: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.CertificateApi()
body =  # Certificate_create_0 |  (optional)

try: 
    api_instance.certificate_post(body=body)
except ApiException as e:
    print("Exception when calling CertificateApi->certificatePost: %s\n" % e)

Parameters

Body parameters
Name Description
body

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


certificateProfilesGet

Returns a dictionary of predefined options for specific use cases i.e openvpn client/server configurations which can be used for creating certificates.


/certificate/profiles

Usage and SDK Samples

curl -X GET -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/certificate/profiles"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.CertificateApi;

import java.io.File;
import java.util.*;

public class CertificateApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        CertificateApi apiInstance = new CertificateApi();
        try {
            apiInstance.certificateProfilesGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling CertificateApi#certificateProfilesGet");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::CertificateApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::CertificateApi->new();

eval { 
    $api_instance->certificateProfilesGet();
};
if ($@) {
    warn "Exception when calling CertificateApi->certificateProfilesGet: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.CertificateApi()

try: 
    api_instance.certificate_profiles_get()
except ApiException as e:
    print("Exception when calling CertificateApi->certificateProfilesGet: %s\n" % e)

Parameters

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


Certificateauthority

certificateauthorityCaSignCsrPost

Sign CSR by Certificate Authority of `ca_id` Sign CSR's and generate a certificate from it. `ca_id` provides which CA is to be used for signing a CSR of `csr_cert_id` which exists in the system `cert_extensions` can be specified if specific extensions are to be set in the newly signed certificate.


/certificateauthority/ca_sign_csr

Usage and SDK Samples

curl -X POST -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/certificateauthority/ca_sign_csr"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.CertificateauthorityApi;

import java.io.File;
import java.util.*;

public class CertificateauthorityApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        CertificateauthorityApi apiInstance = new CertificateauthorityApi();
        Certificateauthority_ca_sign_csr_0 body = ; // Certificateauthority_ca_sign_csr_0 | 
        try {
            apiInstance.certificateauthorityCaSignCsrPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling CertificateauthorityApi#certificateauthorityCaSignCsrPost");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::CertificateauthorityApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::CertificateauthorityApi->new();
my $body = WWW::SwaggerClient::Object::Certificateauthority_ca_sign_csr_0->new(); # Certificateauthority_ca_sign_csr_0 | 

eval { 
    $api_instance->certificateauthorityCaSignCsrPost(body => $body);
};
if ($@) {
    warn "Exception when calling CertificateauthorityApi->certificateauthorityCaSignCsrPost: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.CertificateauthorityApi()
body =  # Certificateauthority_ca_sign_csr_0 |  (optional)

try: 
    api_instance.certificateauthority_ca_sign_csr_post(body=body)
except ApiException as e:
    print("Exception when calling CertificateauthorityApi->certificateauthorityCaSignCsrPost: %s\n" % e)

Parameters

Body parameters
Name Description
body

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


certificateauthorityGet


/certificateauthority

Usage and SDK Samples

curl -X GET -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/certificateauthority?limit=&offset=&count=&sort="
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.CertificateauthorityApi;

import java.io.File;
import java.util.*;

public class CertificateauthorityApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        CertificateauthorityApi apiInstance = new CertificateauthorityApi();
        Integer limit = 56; // Integer | 
        Integer offset = 56; // Integer | 
        Boolean count = true; // Boolean | 
        String sort = sort_example; // String | 
        try {
            apiInstance.certificateauthorityGet(limit, offset, count, sort);
        } catch (ApiException e) {
            System.err.println("Exception when calling CertificateauthorityApi#certificateauthorityGet");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::CertificateauthorityApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::CertificateauthorityApi->new();
my $limit = 56; # Integer | 
my $offset = 56; # Integer | 
my $count = true; # Boolean | 
my $sort = sort_example; # String | 

eval { 
    $api_instance->certificateauthorityGet(limit => $limit, offset => $offset, count => $count, sort => $sort);
};
if ($@) {
    warn "Exception when calling CertificateauthorityApi->certificateauthorityGet: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.CertificateauthorityApi()
limit = 56 # Integer |  (optional)
offset = 56 # Integer |  (optional)
count = true # Boolean |  (optional)
sort = sort_example # String |  (optional)

try: 
    api_instance.certificateauthority_get(limit=limit, offset=offset, count=count, sort=sort)
except ApiException as e:
    print("Exception when calling CertificateauthorityApi->certificateauthorityGet: %s\n" % e)

Parameters

Query parameters
Name Description
limit
Integer
offset
Integer
count
Boolean
sort
String

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


certificateauthorityIdIdDelete

Delete a Certificate Authority of `id`


/certificateauthority/id/{id}

Usage and SDK Samples

curl -X DELETE -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/certificateauthority/id/{id}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.CertificateauthorityApi;

import java.io.File;
import java.util.*;

public class CertificateauthorityApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        CertificateauthorityApi apiInstance = new CertificateauthorityApi();
        Integer id = 56; // Integer | 
        try {
            apiInstance.certificateauthorityIdIdDelete(id);
        } catch (ApiException e) {
            System.err.println("Exception when calling CertificateauthorityApi#certificateauthorityIdIdDelete");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::CertificateauthorityApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::CertificateauthorityApi->new();
my $id = 56; # Integer | 

eval { 
    $api_instance->certificateauthorityIdIdDelete(id => $id);
};
if ($@) {
    warn "Exception when calling CertificateauthorityApi->certificateauthorityIdIdDelete: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.CertificateauthorityApi()
id = 56 # Integer | 

try: 
    api_instance.certificateauthority_id_id_delete(id)
except ApiException as e:
    print("Exception when calling CertificateauthorityApi->certificateauthorityIdIdDelete: %s\n" % e)

Parameters

Path parameters
Name Description
id*
Integer
Required

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


certificateauthorityIdIdGet


/certificateauthority/id/{id}

Usage and SDK Samples

curl -X GET -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/certificateauthority/id/{id}?limit=&offset=&count=&sort="
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.CertificateauthorityApi;

import java.io.File;
import java.util.*;

public class CertificateauthorityApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        CertificateauthorityApi apiInstance = new CertificateauthorityApi();
        array[null] id = ; // array[null] | 
        Integer limit = 56; // Integer | 
        Integer offset = 56; // Integer | 
        Boolean count = true; // Boolean | 
        String sort = sort_example; // String | 
        try {
            apiInstance.certificateauthorityIdIdGet(id, limit, offset, count, sort);
        } catch (ApiException e) {
            System.err.println("Exception when calling CertificateauthorityApi#certificateauthorityIdIdGet");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::CertificateauthorityApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::CertificateauthorityApi->new();
my $id = []; # array[null] | 
my $limit = 56; # Integer | 
my $offset = 56; # Integer | 
my $count = true; # Boolean | 
my $sort = sort_example; # String | 

eval { 
    $api_instance->certificateauthorityIdIdGet(id => $id, limit => $limit, offset => $offset, count => $count, sort => $sort);
};
if ($@) {
    warn "Exception when calling CertificateauthorityApi->certificateauthorityIdIdGet: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.CertificateauthorityApi()
id =  # array[null] | 
limit = 56 # Integer |  (optional)
offset = 56 # Integer |  (optional)
count = true # Boolean |  (optional)
sort = sort_example # String |  (optional)

try: 
    api_instance.certificateauthority_id_id_get(id, limit=limit, offset=offset, count=count, sort=sort)
except ApiException as e:
    print("Exception when calling CertificateauthorityApi->certificateauthorityIdIdGet: %s\n" % e)

Parameters

Path parameters
Name Description
id*
array[null]
Required
Query parameters
Name Description
limit
Integer
offset
Integer
count
Boolean
sort
String

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


certificateauthorityIdIdPut

Update Certificate Authority of `id` Only `name` and `revoked` attribute can be updated. If `revoked` is enabled, the CA and its complete chain is marked as revoked and added to the CA's certificate revocation list.


/certificateauthority/id/{id}

Usage and SDK Samples

curl -X PUT -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/certificateauthority/id/{id}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.CertificateauthorityApi;

import java.io.File;
import java.util.*;

public class CertificateauthorityApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        CertificateauthorityApi apiInstance = new CertificateauthorityApi();
        Integer id = 56; // Integer | 
        Certificateauthority_update_1 body = ; // Certificateauthority_update_1 | 
        try {
            apiInstance.certificateauthorityIdIdPut(id, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling CertificateauthorityApi#certificateauthorityIdIdPut");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::CertificateauthorityApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::CertificateauthorityApi->new();
my $id = 56; # Integer | 
my $body = WWW::SwaggerClient::Object::Certificateauthority_update_1->new(); # Certificateauthority_update_1 | 

eval { 
    $api_instance->certificateauthorityIdIdPut(id => $id, body => $body);
};
if ($@) {
    warn "Exception when calling CertificateauthorityApi->certificateauthorityIdIdPut: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.CertificateauthorityApi()
id = 56 # Integer | 
body =  # Certificateauthority_update_1 |  (optional)

try: 
    api_instance.certificateauthority_id_id_put(id, body=body)
except ApiException as e:
    print("Exception when calling CertificateauthorityApi->certificateauthorityIdIdPut: %s\n" % e)

Parameters

Path parameters
Name Description
id*
Integer
Required
Body parameters
Name Description
body

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


certificateauthorityPost

Create a new Certificate Authority Certificate Authorities are classified under following types with the necessary keywords to be passed for `create_type` attribute to create the respective type of certificate authority 1) Internal Certificate Authority - CA_CREATE_INTERNAL 2) Imported Certificate Authority - CA_CREATE_IMPORTED 3) Intermediate Certificate Authority - CA_CREATE_INTERMEDIATE Created certificate authorities use RSA keys by default. If an Elliptic Curve Key is desired, then it can be specified with the `key_type` attribute. If the `ec_curve` attribute is not specified for the Elliptic Curve Key, default to using "BrainpoolP384R1" curve. A type is selected by the Certificate Authority Service based on `create_type`. The rest of the values are validated accordingly and finally a certificate is made based on the selected type. `cert_extensions` can be specified to set X509v3 extensions.


/certificateauthority

Usage and SDK Samples

curl -X POST -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/certificateauthority"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.CertificateauthorityApi;

import java.io.File;
import java.util.*;

public class CertificateauthorityApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        CertificateauthorityApi apiInstance = new CertificateauthorityApi();
        Certificateauthority_create_0 body = ; // Certificateauthority_create_0 | 
        try {
            apiInstance.certificateauthorityPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling CertificateauthorityApi#certificateauthorityPost");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::CertificateauthorityApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::CertificateauthorityApi->new();
my $body = WWW::SwaggerClient::Object::Certificateauthority_create_0->new(); # Certificateauthority_create_0 | 

eval { 
    $api_instance->certificateauthorityPost(body => $body);
};
if ($@) {
    warn "Exception when calling CertificateauthorityApi->certificateauthorityPost: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.CertificateauthorityApi()
body =  # Certificateauthority_create_0 |  (optional)

try: 
    api_instance.certificateauthority_post(body=body)
except ApiException as e:
    print("Exception when calling CertificateauthorityApi->certificateauthorityPost: %s\n" % e)

Parameters

Body parameters
Name Description
body

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


certificateauthorityProfilesGet

Returns a dictionary of predefined options for specific use cases i.e OpenVPN certificate authority configurations which can be used for creating certificate authorities.


/certificateauthority/profiles

Usage and SDK Samples

curl -X GET -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/certificateauthority/profiles"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.CertificateauthorityApi;

import java.io.File;
import java.util.*;

public class CertificateauthorityApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        CertificateauthorityApi apiInstance = new CertificateauthorityApi();
        try {
            apiInstance.certificateauthorityProfilesGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling CertificateauthorityApi#certificateauthorityProfilesGet");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::CertificateauthorityApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::CertificateauthorityApi->new();

eval { 
    $api_instance->certificateauthorityProfilesGet();
};
if ($@) {
    warn "Exception when calling CertificateauthorityApi->certificateauthorityProfilesGet: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.CertificateauthorityApi()

try: 
    api_instance.certificateauthority_profiles_get()
except ApiException as e:
    print("Exception when calling CertificateauthorityApi->certificateauthorityProfilesGet: %s\n" % e)

Parameters

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


Cloudsync

cloudsyncCommonTaskSchemaGet


/cloudsync/common_task_schema

Usage and SDK Samples

curl -X GET -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/cloudsync/common_task_schema"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.CloudsyncApi;

import java.io.File;
import java.util.*;

public class CloudsyncApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        CloudsyncApi apiInstance = new CloudsyncApi();
        try {
            apiInstance.cloudsyncCommonTaskSchemaGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling CloudsyncApi#cloudsyncCommonTaskSchemaGet");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::CloudsyncApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::CloudsyncApi->new();

eval { 
    $api_instance->cloudsyncCommonTaskSchemaGet();
};
if ($@) {
    warn "Exception when calling CloudsyncApi->cloudsyncCommonTaskSchemaGet: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.CloudsyncApi()

try: 
    api_instance.cloudsync_common_task_schema_get()
except ApiException as e:
    print("Exception when calling CloudsyncApi->cloudsyncCommonTaskSchemaGet: %s\n" % e)

Parameters

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


cloudsyncGet

Query all Cloud Sync Tasks with `query-filters` and `query-options`.


/cloudsync

Usage and SDK Samples

curl -X GET -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/cloudsync?limit=&offset=&count=&sort="
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.CloudsyncApi;

import java.io.File;
import java.util.*;

public class CloudsyncApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        CloudsyncApi apiInstance = new CloudsyncApi();
        Integer limit = 56; // Integer | 
        Integer offset = 56; // Integer | 
        Boolean count = true; // Boolean | 
        String sort = sort_example; // String | 
        try {
            apiInstance.cloudsyncGet(limit, offset, count, sort);
        } catch (ApiException e) {
            System.err.println("Exception when calling CloudsyncApi#cloudsyncGet");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::CloudsyncApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::CloudsyncApi->new();
my $limit = 56; # Integer | 
my $offset = 56; # Integer | 
my $count = true; # Boolean | 
my $sort = sort_example; # String | 

eval { 
    $api_instance->cloudsyncGet(limit => $limit, offset => $offset, count => $count, sort => $sort);
};
if ($@) {
    warn "Exception when calling CloudsyncApi->cloudsyncGet: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.CloudsyncApi()
limit = 56 # Integer |  (optional)
offset = 56 # Integer |  (optional)
count = true # Boolean |  (optional)
sort = sort_example # String |  (optional)

try: 
    api_instance.cloudsync_get(limit=limit, offset=offset, count=count, sort=sort)
except ApiException as e:
    print("Exception when calling CloudsyncApi->cloudsyncGet: %s\n" % e)

Parameters

Query parameters
Name Description
limit
Integer
offset
Integer
count
Boolean
sort
String

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


cloudsyncIdIdAbortPost

Aborts cloud sync task.


/cloudsync/id/{id}/abort

Usage and SDK Samples

curl -X POST -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/cloudsync/id/{id}/abort"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.CloudsyncApi;

import java.io.File;
import java.util.*;

public class CloudsyncApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        CloudsyncApi apiInstance = new CloudsyncApi();
        Integer id = 56; // Integer | 
        Cloudsync_abort body = ; // Cloudsync_abort | 
        try {
            apiInstance.cloudsyncIdIdAbortPost(id, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling CloudsyncApi#cloudsyncIdIdAbortPost");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::CloudsyncApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::CloudsyncApi->new();
my $id = 56; # Integer | 
my $body = WWW::SwaggerClient::Object::Cloudsync_abort->new(); # Cloudsync_abort | 

eval { 
    $api_instance->cloudsyncIdIdAbortPost(id => $id, body => $body);
};
if ($@) {
    warn "Exception when calling CloudsyncApi->cloudsyncIdIdAbortPost: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.CloudsyncApi()
id = 56 # Integer | 
body =  # Cloudsync_abort |  (optional)

try: 
    api_instance.cloudsync_id_id_abort_post(id, body=body)
except ApiException as e:
    print("Exception when calling CloudsyncApi->cloudsyncIdIdAbortPost: %s\n" % e)

Parameters

Path parameters
Name Description
id*
Integer
Required
Body parameters
Name Description
body

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


cloudsyncIdIdDelete

Deletes cloud_sync entry `id`.


/cloudsync/id/{id}

Usage and SDK Samples

curl -X DELETE -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/cloudsync/id/{id}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.CloudsyncApi;

import java.io.File;
import java.util.*;

public class CloudsyncApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        CloudsyncApi apiInstance = new CloudsyncApi();
        Integer id = 56; // Integer | 
        try {
            apiInstance.cloudsyncIdIdDelete(id);
        } catch (ApiException e) {
            System.err.println("Exception when calling CloudsyncApi#cloudsyncIdIdDelete");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::CloudsyncApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::CloudsyncApi->new();
my $id = 56; # Integer | 

eval { 
    $api_instance->cloudsyncIdIdDelete(id => $id);
};
if ($@) {
    warn "Exception when calling CloudsyncApi->cloudsyncIdIdDelete: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.CloudsyncApi()
id = 56 # Integer | 

try: 
    api_instance.cloudsync_id_id_delete(id)
except ApiException as e:
    print("Exception when calling CloudsyncApi->cloudsyncIdIdDelete: %s\n" % e)

Parameters

Path parameters
Name Description
id*
Integer
Required

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


cloudsyncIdIdGet

Query all Cloud Sync Tasks with `query-filters` and `query-options`.


/cloudsync/id/{id}

Usage and SDK Samples

curl -X GET -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/cloudsync/id/{id}?limit=&offset=&count=&sort="
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.CloudsyncApi;

import java.io.File;
import java.util.*;

public class CloudsyncApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        CloudsyncApi apiInstance = new CloudsyncApi();
        array[null] id = ; // array[null] | 
        Integer limit = 56; // Integer | 
        Integer offset = 56; // Integer | 
        Boolean count = true; // Boolean | 
        String sort = sort_example; // String | 
        try {
            apiInstance.cloudsyncIdIdGet(id, limit, offset, count, sort);
        } catch (ApiException e) {
            System.err.println("Exception when calling CloudsyncApi#cloudsyncIdIdGet");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::CloudsyncApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::CloudsyncApi->new();
my $id = []; # array[null] | 
my $limit = 56; # Integer | 
my $offset = 56; # Integer | 
my $count = true; # Boolean | 
my $sort = sort_example; # String | 

eval { 
    $api_instance->cloudsyncIdIdGet(id => $id, limit => $limit, offset => $offset, count => $count, sort => $sort);
};
if ($@) {
    warn "Exception when calling CloudsyncApi->cloudsyncIdIdGet: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.CloudsyncApi()
id =  # array[null] | 
limit = 56 # Integer |  (optional)
offset = 56 # Integer |  (optional)
count = true # Boolean |  (optional)
sort = sort_example # String |  (optional)

try: 
    api_instance.cloudsync_id_id_get(id, limit=limit, offset=offset, count=count, sort=sort)
except ApiException as e:
    print("Exception when calling CloudsyncApi->cloudsyncIdIdGet: %s\n" % e)

Parameters

Path parameters
Name Description
id*
array[null]
Required
Query parameters
Name Description
limit
Integer
offset
Integer
count
Boolean
sort
String

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


cloudsyncIdIdPut

Updates the cloud_sync entry `id` with `data`.


/cloudsync/id/{id}

Usage and SDK Samples

curl -X PUT -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/cloudsync/id/{id}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.CloudsyncApi;

import java.io.File;
import java.util.*;

public class CloudsyncApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        CloudsyncApi apiInstance = new CloudsyncApi();
        Integer id = 56; // Integer | 
        Cloudsync_update_1 body = ; // Cloudsync_update_1 | 
        try {
            apiInstance.cloudsyncIdIdPut(id, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling CloudsyncApi#cloudsyncIdIdPut");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::CloudsyncApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::CloudsyncApi->new();
my $id = 56; # Integer | 
my $body = WWW::SwaggerClient::Object::Cloudsync_update_1->new(); # Cloudsync_update_1 | 

eval { 
    $api_instance->cloudsyncIdIdPut(id => $id, body => $body);
};
if ($@) {
    warn "Exception when calling CloudsyncApi->cloudsyncIdIdPut: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.CloudsyncApi()
id = 56 # Integer | 
body =  # Cloudsync_update_1 |  (optional)

try: 
    api_instance.cloudsync_id_id_put(id, body=body)
except ApiException as e:
    print("Exception when calling CloudsyncApi->cloudsyncIdIdPut: %s\n" % e)

Parameters

Path parameters
Name Description
id*
Integer
Required
Body parameters
Name Description
body

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


cloudsyncIdIdRestorePost

Create the opposite of cloud sync task `id` (PULL if it was PUSH and vice versa).


/cloudsync/id/{id}/restore

Usage and SDK Samples

curl -X POST -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/cloudsync/id/{id}/restore"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.CloudsyncApi;

import java.io.File;
import java.util.*;

public class CloudsyncApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        CloudsyncApi apiInstance = new CloudsyncApi();
        Integer id = 56; // Integer | 
        Cloudsync_restore_1 body = ; // Cloudsync_restore_1 | 
        try {
            apiInstance.cloudsyncIdIdRestorePost(id, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling CloudsyncApi#cloudsyncIdIdRestorePost");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::CloudsyncApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::CloudsyncApi->new();
my $id = 56; # Integer | 
my $body = WWW::SwaggerClient::Object::Cloudsync_restore_1->new(); # Cloudsync_restore_1 | 

eval { 
    $api_instance->cloudsyncIdIdRestorePost(id => $id, body => $body);
};
if ($@) {
    warn "Exception when calling CloudsyncApi->cloudsyncIdIdRestorePost: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.CloudsyncApi()
id = 56 # Integer | 
body =  # Cloudsync_restore_1 |  (optional)

try: 
    api_instance.cloudsync_id_id_restore_post(id, body=body)
except ApiException as e:
    print("Exception when calling CloudsyncApi->cloudsyncIdIdRestorePost: %s\n" % e)

Parameters

Path parameters
Name Description
id*
Integer
Required
Body parameters
Name Description
body

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


cloudsyncIdIdSyncPost

Run the cloud_sync job `id`, syncing the local data to remote.


/cloudsync/id/{id}/sync

Usage and SDK Samples

curl -X POST -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/cloudsync/id/{id}/sync"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.CloudsyncApi;

import java.io.File;
import java.util.*;

public class CloudsyncApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        CloudsyncApi apiInstance = new CloudsyncApi();
        Integer id = 56; // Integer | 
        Cloudsync_sync_1 body = ; // Cloudsync_sync_1 | 
        try {
            apiInstance.cloudsyncIdIdSyncPost(id, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling CloudsyncApi#cloudsyncIdIdSyncPost");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::CloudsyncApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::CloudsyncApi->new();
my $id = 56; # Integer | 
my $body = WWW::SwaggerClient::Object::Cloudsync_sync_1->new(); # Cloudsync_sync_1 | 

eval { 
    $api_instance->cloudsyncIdIdSyncPost(id => $id, body => $body);
};
if ($@) {
    warn "Exception when calling CloudsyncApi->cloudsyncIdIdSyncPost: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.CloudsyncApi()
id = 56 # Integer | 
body =  # Cloudsync_sync_1 |  (optional)

try: 
    api_instance.cloudsync_id_id_sync_post(id, body=body)
except ApiException as e:
    print("Exception when calling CloudsyncApi->cloudsyncIdIdSyncPost: %s\n" % e)

Parameters

Path parameters
Name Description
id*
Integer
Required
Body parameters
Name Description
body

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


cloudsyncListBucketsPost


/cloudsync/list_buckets

Usage and SDK Samples

curl -X POST -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/cloudsync/list_buckets"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.CloudsyncApi;

import java.io.File;
import java.util.*;

public class CloudsyncApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        CloudsyncApi apiInstance = new CloudsyncApi();
        Integer body = ; // Integer | 
        try {
            apiInstance.cloudsyncListBucketsPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling CloudsyncApi#cloudsyncListBucketsPost");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::CloudsyncApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::CloudsyncApi->new();
my $body = WWW::SwaggerClient::Object::Integer->new(); # Integer | 

eval { 
    $api_instance->cloudsyncListBucketsPost(body => $body);
};
if ($@) {
    warn "Exception when calling CloudsyncApi->cloudsyncListBucketsPost: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.CloudsyncApi()
body =  # Integer |  (optional)

try: 
    api_instance.cloudsync_list_buckets_post(body=body)
except ApiException as e:
    print("Exception when calling CloudsyncApi->cloudsyncListBucketsPost: %s\n" % e)

Parameters

Body parameters
Name Description
body

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


cloudsyncListDirectoryPost

List contents of a remote bucket / directory. If remote supports buckets, path is constructed by two keys "bucket"/"folder" in `attributes`. If remote does not support buckets, path is constructed using "folder" key only in `attributes`. "folder" is directory name and "bucket" is bucket name for remote. Path examples: S3 Service `bucketname/directory/name` Dropbox Service `directory/name` `credentials` is a valid id of a Cloud Sync Credential which will be used to connect to the provider.


/cloudsync/list_directory

Usage and SDK Samples

curl -X POST -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/cloudsync/list_directory"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.CloudsyncApi;

import java.io.File;
import java.util.*;

public class CloudsyncApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        CloudsyncApi apiInstance = new CloudsyncApi();
        Cloudsync_list_directory_0 body = ; // Cloudsync_list_directory_0 | 
        try {
            apiInstance.cloudsyncListDirectoryPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling CloudsyncApi#cloudsyncListDirectoryPost");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::CloudsyncApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::CloudsyncApi->new();
my $body = WWW::SwaggerClient::Object::Cloudsync_list_directory_0->new(); # Cloudsync_list_directory_0 | 

eval { 
    $api_instance->cloudsyncListDirectoryPost(body => $body);
};
if ($@) {
    warn "Exception when calling CloudsyncApi->cloudsyncListDirectoryPost: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.CloudsyncApi()
body =  # Cloudsync_list_directory_0 |  (optional)

try: 
    api_instance.cloudsync_list_directory_post(body=body)
except ApiException as e:
    print("Exception when calling CloudsyncApi->cloudsyncListDirectoryPost: %s\n" % e)

Parameters

Body parameters
Name Description
body

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


cloudsyncOnedriveListDrivesPost

Lists all available drives and their types for given Microsoft OneDrive credentials.


/cloudsync/onedrive_list_drives

Usage and SDK Samples

curl -X POST -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/cloudsync/onedrive_list_drives"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.CloudsyncApi;

import java.io.File;
import java.util.*;

public class CloudsyncApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        CloudsyncApi apiInstance = new CloudsyncApi();
        Cloudsync_onedrive_list_drives_0 body = ; // Cloudsync_onedrive_list_drives_0 | 
        try {
            apiInstance.cloudsyncOnedriveListDrivesPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling CloudsyncApi#cloudsyncOnedriveListDrivesPost");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::CloudsyncApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::CloudsyncApi->new();
my $body = WWW::SwaggerClient::Object::Cloudsync_onedrive_list_drives_0->new(); # Cloudsync_onedrive_list_drives_0 | 

eval { 
    $api_instance->cloudsyncOnedriveListDrivesPost(body => $body);
};
if ($@) {
    warn "Exception when calling CloudsyncApi->cloudsyncOnedriveListDrivesPost: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.CloudsyncApi()
body =  # Cloudsync_onedrive_list_drives_0 |  (optional)

try: 
    api_instance.cloudsync_onedrive_list_drives_post(body=body)
except ApiException as e:
    print("Exception when calling CloudsyncApi->cloudsyncOnedriveListDrivesPost: %s\n" % e)

Parameters

Body parameters
Name Description
body

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


cloudsyncPost

Creates a new cloud_sync entry.


/cloudsync

Usage and SDK Samples

curl -X POST -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/cloudsync"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.CloudsyncApi;

import java.io.File;
import java.util.*;

public class CloudsyncApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        CloudsyncApi apiInstance = new CloudsyncApi();
        Cloudsync_create_0 body = ; // Cloudsync_create_0 | 
        try {
            apiInstance.cloudsyncPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling CloudsyncApi#cloudsyncPost");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::CloudsyncApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::CloudsyncApi->new();
my $body = WWW::SwaggerClient::Object::Cloudsync_create_0->new(); # Cloudsync_create_0 | 

eval { 
    $api_instance->cloudsyncPost(body => $body);
};
if ($@) {
    warn "Exception when calling CloudsyncApi->cloudsyncPost: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.CloudsyncApi()
body =  # Cloudsync_create_0 |  (optional)

try: 
    api_instance.cloudsync_post(body=body)
except ApiException as e:
    print("Exception when calling CloudsyncApi->cloudsyncPost: %s\n" % e)

Parameters

Body parameters
Name Description
body

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


cloudsyncProvidersGet

Returns a list of dictionaries of supported providers for Cloud Sync Tasks. `credentials_schema` is JSON schema for credentials attributes. `task_schema` is JSON schema for task attributes. `buckets` is a boolean value which is set to "true" if provider supports buckets. Example of a single provider: [ { "name": "AMAZON_CLOUD_DRIVE", "title": "Amazon Cloud Drive", "credentials_schema": [ { "property": "client_id", "schema": { "title": "Amazon Application Client ID", "_required_": true, "type": "string" } }, { "property": "client_secret", "schema": { "title": "Application Key", "_required_": true, "type": "string" } } ], "credentials_oauth": null, "buckets": false, "bucket_title": "Bucket", "task_schema": [] } ]


/cloudsync/providers

Usage and SDK Samples

curl -X GET -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/cloudsync/providers"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.CloudsyncApi;

import java.io.File;
import java.util.*;

public class CloudsyncApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        CloudsyncApi apiInstance = new CloudsyncApi();
        try {
            apiInstance.cloudsyncProvidersGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling CloudsyncApi#cloudsyncProvidersGet");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::CloudsyncApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::CloudsyncApi->new();

eval { 
    $api_instance->cloudsyncProvidersGet();
};
if ($@) {
    warn "Exception when calling CloudsyncApi->cloudsyncProvidersGet: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.CloudsyncApi()

try: 
    api_instance.cloudsync_providers_get()
except ApiException as e:
    print("Exception when calling CloudsyncApi->cloudsyncProvidersGet: %s\n" % e)

Parameters

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


cloudsyncSyncOnetimePost

Run cloud sync task without creating it.


/cloudsync/sync_onetime

Usage and SDK Samples

curl -X POST -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/cloudsync/sync_onetime"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.CloudsyncApi;

import java.io.File;
import java.util.*;

public class CloudsyncApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        CloudsyncApi apiInstance = new CloudsyncApi();
        Cloudsync_sync_onetime body = ; // Cloudsync_sync_onetime | 
        try {
            apiInstance.cloudsyncSyncOnetimePost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling CloudsyncApi#cloudsyncSyncOnetimePost");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::CloudsyncApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::CloudsyncApi->new();
my $body = WWW::SwaggerClient::Object::Cloudsync_sync_onetime->new(); # Cloudsync_sync_onetime | 

eval { 
    $api_instance->cloudsyncSyncOnetimePost(body => $body);
};
if ($@) {
    warn "Exception when calling CloudsyncApi->cloudsyncSyncOnetimePost: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.CloudsyncApi()
body =  # Cloudsync_sync_onetime |  (optional)

try: 
    api_instance.cloudsync_sync_onetime_post(body=body)
except ApiException as e:
    print("Exception when calling CloudsyncApi->cloudsyncSyncOnetimePost: %s\n" % e)

Parameters

Body parameters
Name Description
body

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


CloudsyncCredentials

cloudsyncCredentialsGet


/cloudsync/credentials

Usage and SDK Samples

curl -X GET -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/cloudsync/credentials?limit=&offset=&count=&sort="
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.CloudsyncCredentialsApi;

import java.io.File;
import java.util.*;

public class CloudsyncCredentialsApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        CloudsyncCredentialsApi apiInstance = new CloudsyncCredentialsApi();
        Integer limit = 56; // Integer | 
        Integer offset = 56; // Integer | 
        Boolean count = true; // Boolean | 
        String sort = sort_example; // String | 
        try {
            apiInstance.cloudsyncCredentialsGet(limit, offset, count, sort);
        } catch (ApiException e) {
            System.err.println("Exception when calling CloudsyncCredentialsApi#cloudsyncCredentialsGet");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::CloudsyncCredentialsApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::CloudsyncCredentialsApi->new();
my $limit = 56; # Integer | 
my $offset = 56; # Integer | 
my $count = true; # Boolean | 
my $sort = sort_example; # String | 

eval { 
    $api_instance->cloudsyncCredentialsGet(limit => $limit, offset => $offset, count => $count, sort => $sort);
};
if ($@) {
    warn "Exception when calling CloudsyncCredentialsApi->cloudsyncCredentialsGet: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.CloudsyncCredentialsApi()
limit = 56 # Integer |  (optional)
offset = 56 # Integer |  (optional)
count = true # Boolean |  (optional)
sort = sort_example # String |  (optional)

try: 
    api_instance.cloudsync_credentials_get(limit=limit, offset=offset, count=count, sort=sort)
except ApiException as e:
    print("Exception when calling CloudsyncCredentialsApi->cloudsyncCredentialsGet: %s\n" % e)

Parameters

Query parameters
Name Description
limit
Integer
offset
Integer
count
Boolean
sort
String

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


cloudsyncCredentialsIdIdDelete

Delete Cloud Sync Credentials of `id`.


/cloudsync/credentials/id/{id}

Usage and SDK Samples

curl -X DELETE -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/cloudsync/credentials/id/{id}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.CloudsyncCredentialsApi;

import java.io.File;
import java.util.*;

public class CloudsyncCredentialsApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        CloudsyncCredentialsApi apiInstance = new CloudsyncCredentialsApi();
        Integer id = 56; // Integer | 
        try {
            apiInstance.cloudsyncCredentialsIdIdDelete(id);
        } catch (ApiException e) {
            System.err.println("Exception when calling CloudsyncCredentialsApi#cloudsyncCredentialsIdIdDelete");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::CloudsyncCredentialsApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::CloudsyncCredentialsApi->new();
my $id = 56; # Integer | 

eval { 
    $api_instance->cloudsyncCredentialsIdIdDelete(id => $id);
};
if ($@) {
    warn "Exception when calling CloudsyncCredentialsApi->cloudsyncCredentialsIdIdDelete: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.CloudsyncCredentialsApi()
id = 56 # Integer | 

try: 
    api_instance.cloudsync_credentials_id_id_delete(id)
except ApiException as e:
    print("Exception when calling CloudsyncCredentialsApi->cloudsyncCredentialsIdIdDelete: %s\n" % e)

Parameters

Path parameters
Name Description
id*
Integer
Required

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


cloudsyncCredentialsIdIdGet


/cloudsync/credentials/id/{id}

Usage and SDK Samples

curl -X GET -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/cloudsync/credentials/id/{id}?limit=&offset=&count=&sort="
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.CloudsyncCredentialsApi;

import java.io.File;
import java.util.*;

public class CloudsyncCredentialsApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        CloudsyncCredentialsApi apiInstance = new CloudsyncCredentialsApi();
        array[null] id = ; // array[null] | 
        Integer limit = 56; // Integer | 
        Integer offset = 56; // Integer | 
        Boolean count = true; // Boolean | 
        String sort = sort_example; // String | 
        try {
            apiInstance.cloudsyncCredentialsIdIdGet(id, limit, offset, count, sort);
        } catch (ApiException e) {
            System.err.println("Exception when calling CloudsyncCredentialsApi#cloudsyncCredentialsIdIdGet");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::CloudsyncCredentialsApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::CloudsyncCredentialsApi->new();
my $id = []; # array[null] | 
my $limit = 56; # Integer | 
my $offset = 56; # Integer | 
my $count = true; # Boolean | 
my $sort = sort_example; # String | 

eval { 
    $api_instance->cloudsyncCredentialsIdIdGet(id => $id, limit => $limit, offset => $offset, count => $count, sort => $sort);
};
if ($@) {
    warn "Exception when calling CloudsyncCredentialsApi->cloudsyncCredentialsIdIdGet: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.CloudsyncCredentialsApi()
id =  # array[null] | 
limit = 56 # Integer |  (optional)
offset = 56 # Integer |  (optional)
count = true # Boolean |  (optional)
sort = sort_example # String |  (optional)

try: 
    api_instance.cloudsync_credentials_id_id_get(id, limit=limit, offset=offset, count=count, sort=sort)
except ApiException as e:
    print("Exception when calling CloudsyncCredentialsApi->cloudsyncCredentialsIdIdGet: %s\n" % e)

Parameters

Path parameters
Name Description
id*
array[null]
Required
Query parameters
Name Description
limit
Integer
offset
Integer
count
Boolean
sort
String

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


cloudsyncCredentialsIdIdPut

Update Cloud Sync Credentials of `id`.


/cloudsync/credentials/id/{id}

Usage and SDK Samples

curl -X PUT -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/cloudsync/credentials/id/{id}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.CloudsyncCredentialsApi;

import java.io.File;
import java.util.*;

public class CloudsyncCredentialsApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        CloudsyncCredentialsApi apiInstance = new CloudsyncCredentialsApi();
        Integer id = 56; // Integer | 
        Cloudsync_credentials_update_1 body = ; // Cloudsync_credentials_update_1 | 
        try {
            apiInstance.cloudsyncCredentialsIdIdPut(id, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling CloudsyncCredentialsApi#cloudsyncCredentialsIdIdPut");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::CloudsyncCredentialsApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::CloudsyncCredentialsApi->new();
my $id = 56; # Integer | 
my $body = WWW::SwaggerClient::Object::Cloudsync_credentials_update_1->new(); # Cloudsync_credentials_update_1 | 

eval { 
    $api_instance->cloudsyncCredentialsIdIdPut(id => $id, body => $body);
};
if ($@) {
    warn "Exception when calling CloudsyncCredentialsApi->cloudsyncCredentialsIdIdPut: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.CloudsyncCredentialsApi()
id = 56 # Integer | 
body =  # Cloudsync_credentials_update_1 |  (optional)

try: 
    api_instance.cloudsync_credentials_id_id_put(id, body=body)
except ApiException as e:
    print("Exception when calling CloudsyncCredentialsApi->cloudsyncCredentialsIdIdPut: %s\n" % e)

Parameters

Path parameters
Name Description
id*
Integer
Required
Body parameters
Name Description
body

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


cloudsyncCredentialsPost

Create Cloud Sync Credentials. `attributes` is a dictionary of valid values which will be used to authorize with the `provider`.


/cloudsync/credentials

Usage and SDK Samples

curl -X POST -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/cloudsync/credentials"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.CloudsyncCredentialsApi;

import java.io.File;
import java.util.*;

public class CloudsyncCredentialsApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        CloudsyncCredentialsApi apiInstance = new CloudsyncCredentialsApi();
        Cloudsync_credentials_create_0 body = ; // Cloudsync_credentials_create_0 | 
        try {
            apiInstance.cloudsyncCredentialsPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling CloudsyncCredentialsApi#cloudsyncCredentialsPost");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::CloudsyncCredentialsApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::CloudsyncCredentialsApi->new();
my $body = WWW::SwaggerClient::Object::Cloudsync_credentials_create_0->new(); # Cloudsync_credentials_create_0 | 

eval { 
    $api_instance->cloudsyncCredentialsPost(body => $body);
};
if ($@) {
    warn "Exception when calling CloudsyncCredentialsApi->cloudsyncCredentialsPost: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.CloudsyncCredentialsApi()
body =  # Cloudsync_credentials_create_0 |  (optional)

try: 
    api_instance.cloudsync_credentials_post(body=body)
except ApiException as e:
    print("Exception when calling CloudsyncCredentialsApi->cloudsyncCredentialsPost: %s\n" % e)

Parameters

Body parameters
Name Description
body

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


cloudsyncCredentialsVerifyPost

Verify if `attributes` provided for `provider` are authorized by the `provider`.


/cloudsync/credentials/verify

Usage and SDK Samples

curl -X POST -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/cloudsync/credentials/verify"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.CloudsyncCredentialsApi;

import java.io.File;
import java.util.*;

public class CloudsyncCredentialsApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        CloudsyncCredentialsApi apiInstance = new CloudsyncCredentialsApi();
        Cloudsync_credentials_verify_0 body = ; // Cloudsync_credentials_verify_0 | 
        try {
            apiInstance.cloudsyncCredentialsVerifyPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling CloudsyncCredentialsApi#cloudsyncCredentialsVerifyPost");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::CloudsyncCredentialsApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::CloudsyncCredentialsApi->new();
my $body = WWW::SwaggerClient::Object::Cloudsync_credentials_verify_0->new(); # Cloudsync_credentials_verify_0 | 

eval { 
    $api_instance->cloudsyncCredentialsVerifyPost(body => $body);
};
if ($@) {
    warn "Exception when calling CloudsyncCredentialsApi->cloudsyncCredentialsVerifyPost: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.CloudsyncCredentialsApi()
body =  # Cloudsync_credentials_verify_0 |  (optional)

try: 
    api_instance.cloudsync_credentials_verify_post(body=body)
except ApiException as e:
    print("Exception when calling CloudsyncCredentialsApi->cloudsyncCredentialsVerifyPost: %s\n" % e)

Parameters

Body parameters
Name Description
body

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


Config

configResetPost

Reset database to configuration defaults. If `reboot` is true this job will reboot the system after its completed with a delay of 10 seconds.


/config/reset

Usage and SDK Samples

curl -X POST -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/config/reset"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.ConfigApi;

import java.io.File;
import java.util.*;

public class ConfigApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        ConfigApi apiInstance = new ConfigApi();
        Config_reset_0 body = ; // Config_reset_0 | 
        try {
            apiInstance.configResetPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling ConfigApi#configResetPost");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::ConfigApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::ConfigApi->new();
my $body = WWW::SwaggerClient::Object::Config_reset_0->new(); # Config_reset_0 | 

eval { 
    $api_instance->configResetPost(body => $body);
};
if ($@) {
    warn "Exception when calling ConfigApi->configResetPost: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.ConfigApi()
body =  # Config_reset_0 |  (optional)

try: 
    api_instance.config_reset_post(body=body)
except ApiException as e:
    print("Exception when calling ConfigApi->configResetPost: %s\n" % e)

Parameters

Body parameters
Name Description
body

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


Core

coreBulkPost

Will loop on a list of items for the given method, returning a list of dicts containing a result and error key. Result will be the message returned by the method being called, or a string of an error, in which case the error key will be the exception


/core/bulk

Usage and SDK Samples

curl -X POST -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/core/bulk"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.CoreApi;

import java.io.File;
import java.util.*;

public class CoreApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        CoreApi apiInstance = new CoreApi();
        Core_bulk body = ; // Core_bulk | 
        try {
            apiInstance.coreBulkPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling CoreApi#coreBulkPost");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::CoreApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::CoreApi->new();
my $body = WWW::SwaggerClient::Object::Core_bulk->new(); # Core_bulk | 

eval { 
    $api_instance->coreBulkPost(body => $body);
};
if ($@) {
    warn "Exception when calling CoreApi->coreBulkPost: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.CoreApi()
body =  # Core_bulk |  (optional)

try: 
    api_instance.core_bulk_post(body=body)
except ApiException as e:
    print("Exception when calling CoreApi->coreBulkPost: %s\n" % e)

Parameters

Body parameters
Name Description
body

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


coreDebugPost

Setup middlewared for remote debugging. engines: - PTVS: Python Visual Studio - PYDEV: Python Dev (Eclipse/PyCharm) - REMOTE_PDB: Remote vanilla PDB (over TCP sockets) options: - secret: password for PTVS - host: required for PYDEV, hostname of local computer (developer workstation) - local_path: required for PYDEV, path for middlewared source in local computer (e.g. /home/user/freenas/src/middlewared/middlewared - threaded: run debugger in a new thread instead of event loop


/core/debug

Usage and SDK Samples

curl -X POST -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/core/debug"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.CoreApi;

import java.io.File;
import java.util.*;

public class CoreApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        CoreApi apiInstance = new CoreApi();
        Core_debug body = ; // Core_debug | 
        try {
            apiInstance.coreDebugPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling CoreApi#coreDebugPost");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::CoreApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::CoreApi->new();
my $body = WWW::SwaggerClient::Object::Core_debug->new(); # Core_debug | 

eval { 
    $api_instance->coreDebugPost(body => $body);
};
if ($@) {
    warn "Exception when calling CoreApi->coreDebugPost: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.CoreApi()
body =  # Core_debug |  (optional)

try: 
    api_instance.core_debug_post(body=body)
except ApiException as e:
    print("Exception when calling CoreApi->coreDebugPost: %s\n" % e)

Parameters

Body parameters
Name Description
body

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


coreDownloadPost

Core helper to call a job marked for download. Returns the job id and the URL for download.


/core/download

Usage and SDK Samples

curl -X POST -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/core/download"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.CoreApi;

import java.io.File;
import java.util.*;

public class CoreApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        CoreApi apiInstance = new CoreApi();
        Core_download body = ; // Core_download | 
        try {
            apiInstance.coreDownloadPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling CoreApi#coreDownloadPost");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::CoreApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::CoreApi->new();
my $body = WWW::SwaggerClient::Object::Core_download->new(); # Core_download | 

eval { 
    $api_instance->coreDownloadPost(body => $body);
};
if ($@) {
    warn "Exception when calling CoreApi->coreDownloadPost: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.CoreApi()
body =  # Core_download |  (optional)

try: 
    api_instance.core_download_post(body=body)
except ApiException as e:
    print("Exception when calling CoreApi->coreDownloadPost: %s\n" % e)

Parameters

Body parameters
Name Description
body

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


coreGetEventsGet

Returns metadata for every possible event emitted from websocket server.


/core/get_events

Usage and SDK Samples

curl -X GET -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/core/get_events"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.CoreApi;

import java.io.File;
import java.util.*;

public class CoreApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        CoreApi apiInstance = new CoreApi();
        try {
            apiInstance.coreGetEventsGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling CoreApi#coreGetEventsGet");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::CoreApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::CoreApi->new();

eval { 
    $api_instance->coreGetEventsGet();
};
if ($@) {
    warn "Exception when calling CoreApi->coreGetEventsGet: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.CoreApi()

try: 
    api_instance.core_get_events_get()
except ApiException as e:
    print("Exception when calling CoreApi->coreGetEventsGet: %s\n" % e)

Parameters

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


coreGetJobsGet

Get the long running jobs.


/core/get_jobs

Usage and SDK Samples

curl -X GET -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/core/get_jobs?limit=&offset=&count=&sort="
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.CoreApi;

import java.io.File;
import java.util.*;

public class CoreApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        CoreApi apiInstance = new CoreApi();
        Integer limit = 56; // Integer | 
        Integer offset = 56; // Integer | 
        Boolean count = true; // Boolean | 
        String sort = sort_example; // String | 
        try {
            apiInstance.coreGetJobsGet(limit, offset, count, sort);
        } catch (ApiException e) {
            System.err.println("Exception when calling CoreApi#coreGetJobsGet");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::CoreApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::CoreApi->new();
my $limit = 56; # Integer | 
my $offset = 56; # Integer | 
my $count = true; # Boolean | 
my $sort = sort_example; # String | 

eval { 
    $api_instance->coreGetJobsGet(limit => $limit, offset => $offset, count => $count, sort => $sort);
};
if ($@) {
    warn "Exception when calling CoreApi->coreGetJobsGet: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.CoreApi()
limit = 56 # Integer |  (optional)
offset = 56 # Integer |  (optional)
count = true # Boolean |  (optional)
sort = sort_example # String |  (optional)

try: 
    api_instance.core_get_jobs_get(limit=limit, offset=offset, count=count, sort=sort)
except ApiException as e:
    print("Exception when calling CoreApi->coreGetJobsGet: %s\n" % e)

Parameters

Query parameters
Name Description
limit
Integer
offset
Integer
count
Boolean
sort
String

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


coreGetMethodsPost

Return methods metadata of every available service. `service` parameter is optional and filters the result for a single service.


/core/get_methods

Usage and SDK Samples

curl -X POST -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/core/get_methods"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.CoreApi;

import java.io.File;
import java.util.*;

public class CoreApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        CoreApi apiInstance = new CoreApi();
        String body = ; // String | 
        try {
            apiInstance.coreGetMethodsPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling CoreApi#coreGetMethodsPost");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::CoreApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::CoreApi->new();
my $body = WWW::SwaggerClient::Object::String->new(); # String | 

eval { 
    $api_instance->coreGetMethodsPost(body => $body);
};
if ($@) {
    warn "Exception when calling CoreApi->coreGetMethodsPost: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.CoreApi()
body =  # String |  (optional)

try: 
    api_instance.core_get_methods_post(body=body)
except ApiException as e:
    print("Exception when calling CoreApi->coreGetMethodsPost: %s\n" % e)

Parameters

Body parameters
Name Description
body

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


coreGetServicesGet

Returns a list of all registered services.


/core/get_services

Usage and SDK Samples

curl -X GET -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/core/get_services"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.CoreApi;

import java.io.File;
import java.util.*;

public class CoreApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        CoreApi apiInstance = new CoreApi();
        try {
            apiInstance.coreGetServicesGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling CoreApi#coreGetServicesGet");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::CoreApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::CoreApi->new();

eval { 
    $api_instance->coreGetServicesGet();
};
if ($@) {
    warn "Exception when calling CoreApi->coreGetServicesGet: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.CoreApi()

try: 
    api_instance.core_get_services_get()
except ApiException as e:
    print("Exception when calling CoreApi->coreGetServicesGet: %s\n" % e)

Parameters

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


coreJobAbortPost


/core/job_abort

Usage and SDK Samples

curl -X POST -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/core/job_abort"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.CoreApi;

import java.io.File;
import java.util.*;

public class CoreApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        CoreApi apiInstance = new CoreApi();
        Integer body = ; // Integer | 
        try {
            apiInstance.coreJobAbortPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling CoreApi#coreJobAbortPost");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::CoreApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::CoreApi->new();
my $body = WWW::SwaggerClient::Object::Integer->new(); # Integer | 

eval { 
    $api_instance->coreJobAbortPost(body => $body);
};
if ($@) {
    warn "Exception when calling CoreApi->coreJobAbortPost: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.CoreApi()
body =  # Integer |  (optional)

try: 
    api_instance.core_job_abort_post(body=body)
except ApiException as e:
    print("Exception when calling CoreApi->coreJobAbortPost: %s\n" % e)

Parameters

Body parameters
Name Description
body

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


coreJobUpdatePost


/core/job_update

Usage and SDK Samples

curl -X POST -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/core/job_update"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.CoreApi;

import java.io.File;
import java.util.*;

public class CoreApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        CoreApi apiInstance = new CoreApi();
        Core_job_update body = ; // Core_job_update | 
        try {
            apiInstance.coreJobUpdatePost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling CoreApi#coreJobUpdatePost");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::CoreApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::CoreApi->new();
my $body = WWW::SwaggerClient::Object::Core_job_update->new(); # Core_job_update | 

eval { 
    $api_instance->coreJobUpdatePost(body => $body);
};
if ($@) {
    warn "Exception when calling CoreApi->coreJobUpdatePost: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.CoreApi()
body =  # Core_job_update |  (optional)

try: 
    api_instance.core_job_update_post(body=body)
except ApiException as e:
    print("Exception when calling CoreApi->coreJobUpdatePost: %s\n" % e)

Parameters

Body parameters
Name Description
body

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


coreJobWaitPost


/core/job_wait

Usage and SDK Samples

curl -X POST -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/core/job_wait"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.CoreApi;

import java.io.File;
import java.util.*;

public class CoreApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        CoreApi apiInstance = new CoreApi();
        Integer body = ; // Integer | 
        try {
            apiInstance.coreJobWaitPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling CoreApi#coreJobWaitPost");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::CoreApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::CoreApi->new();
my $body = WWW::SwaggerClient::Object::Integer->new(); # Integer | 

eval { 
    $api_instance->coreJobWaitPost(body => $body);
};
if ($@) {
    warn "Exception when calling CoreApi->coreJobWaitPost: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.CoreApi()
body =  # Integer |  (optional)

try: 
    api_instance.core_job_wait_post(body=body)
except ApiException as e:
    print("Exception when calling CoreApi->coreJobWaitPost: %s\n" % e)

Parameters

Body parameters
Name Description
body

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


corePingGet

Utility method which just returns "pong". Can be used to keep connection/authtoken alive instead of using "ping" protocol message.


/core/ping

Usage and SDK Samples

curl -X GET -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/core/ping"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.CoreApi;

import java.io.File;
import java.util.*;

public class CoreApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        CoreApi apiInstance = new CoreApi();
        try {
            apiInstance.corePingGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling CoreApi#corePingGet");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::CoreApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::CoreApi->new();

eval { 
    $api_instance->corePingGet();
};
if ($@) {
    warn "Exception when calling CoreApi->corePingGet: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.CoreApi()

try: 
    api_instance.core_ping_get()
except ApiException as e:
    print("Exception when calling CoreApi->corePingGet: %s\n" % e)

Parameters

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


corePingRemotePost

Method that will send an ICMP echo request to "hostname" and will wait up to "timeout" for a reply.


/core/ping_remote

Usage and SDK Samples

curl -X POST -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/core/ping_remote"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.CoreApi;

import java.io.File;
import java.util.*;

public class CoreApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        CoreApi apiInstance = new CoreApi();
        Core_ping_remote_0 body = ; // Core_ping_remote_0 | 
        try {
            apiInstance.corePingRemotePost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling CoreApi#corePingRemotePost");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::CoreApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::CoreApi->new();
my $body = WWW::SwaggerClient::Object::Core_ping_remote_0->new(); # Core_ping_remote_0 | 

eval { 
    $api_instance->corePingRemotePost(body => $body);
};
if ($@) {
    warn "Exception when calling CoreApi->corePingRemotePost: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.CoreApi()
body =  # Core_ping_remote_0 |  (optional)

try: 
    api_instance.core_ping_remote_post(body=body)
except ApiException as e:
    print("Exception when calling CoreApi->corePingRemotePost: %s\n" % e)

Parameters

Body parameters
Name Description
body

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


coreResizeShellPost

Resize terminal session (/websocket/shell) to cols x rows


/core/resize_shell

Usage and SDK Samples

curl -X POST -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/core/resize_shell"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.CoreApi;

import java.io.File;
import java.util.*;

public class CoreApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        CoreApi apiInstance = new CoreApi();
        Core_resize_shell body = ; // Core_resize_shell | 
        try {
            apiInstance.coreResizeShellPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling CoreApi#coreResizeShellPost");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::CoreApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::CoreApi->new();
my $body = WWW::SwaggerClient::Object::Core_resize_shell->new(); # Core_resize_shell | 

eval { 
    $api_instance->coreResizeShellPost(body => $body);
};
if ($@) {
    warn "Exception when calling CoreApi->coreResizeShellPost: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.CoreApi()
body =  # Core_resize_shell |  (optional)

try: 
    api_instance.core_resize_shell_post(body=body)
except ApiException as e:
    print("Exception when calling CoreApi->coreResizeShellPost: %s\n" % e)

Parameters

Body parameters
Name Description
body

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


coreSessionsGet

Get currently open websocket sessions.


/core/sessions

Usage and SDK Samples

curl -X GET -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/core/sessions?limit=&offset=&count=&sort="
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.CoreApi;

import java.io.File;
import java.util.*;

public class CoreApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        CoreApi apiInstance = new CoreApi();
        Integer limit = 56; // Integer | 
        Integer offset = 56; // Integer | 
        Boolean count = true; // Boolean | 
        String sort = sort_example; // String | 
        try {
            apiInstance.coreSessionsGet(limit, offset, count, sort);
        } catch (ApiException e) {
            System.err.println("Exception when calling CoreApi#coreSessionsGet");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::CoreApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::CoreApi->new();
my $limit = 56; # Integer | 
my $offset = 56; # Integer | 
my $count = true; # Boolean | 
my $sort = sort_example; # String | 

eval { 
    $api_instance->coreSessionsGet(limit => $limit, offset => $offset, count => $count, sort => $sort);
};
if ($@) {
    warn "Exception when calling CoreApi->coreSessionsGet: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.CoreApi()
limit = 56 # Integer |  (optional)
offset = 56 # Integer |  (optional)
count = true # Boolean |  (optional)
sort = sort_example # String |  (optional)

try: 
    api_instance.core_sessions_get(limit=limit, offset=offset, count=count, sort=sort)
except ApiException as e:
    print("Exception when calling CoreApi->coreSessionsGet: %s\n" % e)

Parameters

Query parameters
Name Description
limit
Integer
offset
Integer
count
Boolean
sort
String

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


Cronjob

cronjobGet


/cronjob

Usage and SDK Samples

curl -X GET -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/cronjob?limit=&offset=&count=&sort="
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.CronjobApi;

import java.io.File;
import java.util.*;

public class CronjobApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        CronjobApi apiInstance = new CronjobApi();
        Integer limit = 56; // Integer | 
        Integer offset = 56; // Integer | 
        Boolean count = true; // Boolean | 
        String sort = sort_example; // String | 
        try {
            apiInstance.cronjobGet(limit, offset, count, sort);
        } catch (ApiException e) {
            System.err.println("Exception when calling CronjobApi#cronjobGet");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::CronjobApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::CronjobApi->new();
my $limit = 56; # Integer | 
my $offset = 56; # Integer | 
my $count = true; # Boolean | 
my $sort = sort_example; # String | 

eval { 
    $api_instance->cronjobGet(limit => $limit, offset => $offset, count => $count, sort => $sort);
};
if ($@) {
    warn "Exception when calling CronjobApi->cronjobGet: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.CronjobApi()
limit = 56 # Integer |  (optional)
offset = 56 # Integer |  (optional)
count = true # Boolean |  (optional)
sort = sort_example # String |  (optional)

try: 
    api_instance.cronjob_get(limit=limit, offset=offset, count=count, sort=sort)
except ApiException as e:
    print("Exception when calling CronjobApi->cronjobGet: %s\n" % e)

Parameters

Query parameters
Name Description
limit
Integer
offset
Integer
count
Boolean
sort
String

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


cronjobIdIdDelete

Delete cronjob of `id`.


/cronjob/id/{id}

Usage and SDK Samples

curl -X DELETE -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/cronjob/id/{id}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.CronjobApi;

import java.io.File;
import java.util.*;

public class CronjobApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        CronjobApi apiInstance = new CronjobApi();
        Integer id = 56; // Integer | 
        try {
            apiInstance.cronjobIdIdDelete(id);
        } catch (ApiException e) {
            System.err.println("Exception when calling CronjobApi#cronjobIdIdDelete");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::CronjobApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::CronjobApi->new();
my $id = 56; # Integer | 

eval { 
    $api_instance->cronjobIdIdDelete(id => $id);
};
if ($@) {
    warn "Exception when calling CronjobApi->cronjobIdIdDelete: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.CronjobApi()
id = 56 # Integer | 

try: 
    api_instance.cronjob_id_id_delete(id)
except ApiException as e:
    print("Exception when calling CronjobApi->cronjobIdIdDelete: %s\n" % e)

Parameters

Path parameters
Name Description
id*
Integer
Required

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


cronjobIdIdGet


/cronjob/id/{id}

Usage and SDK Samples

curl -X GET -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/cronjob/id/{id}?limit=&offset=&count=&sort="
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.CronjobApi;

import java.io.File;
import java.util.*;

public class CronjobApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        CronjobApi apiInstance = new CronjobApi();
        array[null] id = ; // array[null] | 
        Integer limit = 56; // Integer | 
        Integer offset = 56; // Integer | 
        Boolean count = true; // Boolean | 
        String sort = sort_example; // String | 
        try {
            apiInstance.cronjobIdIdGet(id, limit, offset, count, sort);
        } catch (ApiException e) {
            System.err.println("Exception when calling CronjobApi#cronjobIdIdGet");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::CronjobApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::CronjobApi->new();
my $id = []; # array[null] | 
my $limit = 56; # Integer | 
my $offset = 56; # Integer | 
my $count = true; # Boolean | 
my $sort = sort_example; # String | 

eval { 
    $api_instance->cronjobIdIdGet(id => $id, limit => $limit, offset => $offset, count => $count, sort => $sort);
};
if ($@) {
    warn "Exception when calling CronjobApi->cronjobIdIdGet: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.CronjobApi()
id =  # array[null] | 
limit = 56 # Integer |  (optional)
offset = 56 # Integer |  (optional)
count = true # Boolean |  (optional)
sort = sort_example # String |  (optional)

try: 
    api_instance.cronjob_id_id_get(id, limit=limit, offset=offset, count=count, sort=sort)
except ApiException as e:
    print("Exception when calling CronjobApi->cronjobIdIdGet: %s\n" % e)

Parameters

Path parameters
Name Description
id*
array[null]
Required
Query parameters
Name Description
limit
Integer
offset
Integer
count
Boolean
sort
String

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


cronjobIdIdPut

Update cronjob of `id`.


/cronjob/id/{id}

Usage and SDK Samples

curl -X PUT -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/cronjob/id/{id}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.CronjobApi;

import java.io.File;
import java.util.*;

public class CronjobApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        CronjobApi apiInstance = new CronjobApi();
        Integer id = 56; // Integer | 
        Cronjob_update_1 body = ; // Cronjob_update_1 | 
        try {
            apiInstance.cronjobIdIdPut(id, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling CronjobApi#cronjobIdIdPut");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::CronjobApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::CronjobApi->new();
my $id = 56; # Integer | 
my $body = WWW::SwaggerClient::Object::Cronjob_update_1->new(); # Cronjob_update_1 | 

eval { 
    $api_instance->cronjobIdIdPut(id => $id, body => $body);
};
if ($@) {
    warn "Exception when calling CronjobApi->cronjobIdIdPut: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.CronjobApi()
id = 56 # Integer | 
body =  # Cronjob_update_1 |  (optional)

try: 
    api_instance.cronjob_id_id_put(id, body=body)
except ApiException as e:
    print("Exception when calling CronjobApi->cronjobIdIdPut: %s\n" % e)

Parameters

Path parameters
Name Description
id*
Integer
Required
Body parameters
Name Description
body

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


cronjobPost

Create a new cron job. `stderr` and `stdout` are boolean values which if `true`, represent that we would like to suppress standard error / standard output respectively.


/cronjob

Usage and SDK Samples

curl -X POST -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/cronjob"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.CronjobApi;

import java.io.File;
import java.util.*;

public class CronjobApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        CronjobApi apiInstance = new CronjobApi();
        Cronjob_create_0 body = ; // Cronjob_create_0 | 
        try {
            apiInstance.cronjobPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling CronjobApi#cronjobPost");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::CronjobApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::CronjobApi->new();
my $body = WWW::SwaggerClient::Object::Cronjob_create_0->new(); # Cronjob_create_0 | 

eval { 
    $api_instance->cronjobPost(body => $body);
};
if ($@) {
    warn "Exception when calling CronjobApi->cronjobPost: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.CronjobApi()
body =  # Cronjob_create_0 |  (optional)

try: 
    api_instance.cronjob_post(body=body)
except ApiException as e:
    print("Exception when calling CronjobApi->cronjobPost: %s\n" % e)

Parameters

Body parameters
Name Description
body

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


cronjobRunPost

Job to run cronjob task of `id`.


/cronjob/run

Usage and SDK Samples

curl -X POST -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/cronjob/run"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.CronjobApi;

import java.io.File;
import java.util.*;

public class CronjobApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        CronjobApi apiInstance = new CronjobApi();
        Cronjob_run body = ; // Cronjob_run | 
        try {
            apiInstance.cronjobRunPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling CronjobApi#cronjobRunPost");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::CronjobApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::CronjobApi->new();
my $body = WWW::SwaggerClient::Object::Cronjob_run->new(); # Cronjob_run | 

eval { 
    $api_instance->cronjobRunPost(body => $body);
};
if ($@) {
    warn "Exception when calling CronjobApi->cronjobRunPost: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.CronjobApi()
body =  # Cronjob_run |  (optional)

try: 
    api_instance.cronjob_run_post(body=body)
except ApiException as e:
    print("Exception when calling CronjobApi->cronjobRunPost: %s\n" % e)

Parameters

Body parameters
Name Description
body

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


Device

deviceGetInfoPost

Get info for SERIAL/DISK device types.


/device/get_info

Usage and SDK Samples

curl -X POST -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/device/get_info"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.DeviceApi;

import java.io.File;
import java.util.*;

public class DeviceApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        DeviceApi apiInstance = new DeviceApi();
        String body = ; // String | 
        try {
            apiInstance.deviceGetInfoPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling DeviceApi#deviceGetInfoPost");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::DeviceApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::DeviceApi->new();
my $body = WWW::SwaggerClient::Object::String->new(); # String | 

eval { 
    $api_instance->deviceGetInfoPost(body => $body);
};
if ($@) {
    warn "Exception when calling DeviceApi->deviceGetInfoPost: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.DeviceApi()
body =  # String |  (optional)

try: 
    api_instance.device_get_info_post(body=body)
except ApiException as e:
    print("Exception when calling DeviceApi->deviceGetInfoPost: %s\n" % e)

Parameters

Body parameters
Name Description
body

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


Directoryservices

directoryservicesCacheRefreshGet


/directoryservices/cache_refresh

Usage and SDK Samples

curl -X GET -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/directoryservices/cache_refresh"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.DirectoryservicesApi;

import java.io.File;
import java.util.*;

public class DirectoryservicesApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        DirectoryservicesApi apiInstance = new DirectoryservicesApi();
        try {
            apiInstance.directoryservicesCacheRefreshGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling DirectoryservicesApi#directoryservicesCacheRefreshGet");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::DirectoryservicesApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::DirectoryservicesApi->new();

eval { 
    $api_instance->directoryservicesCacheRefreshGet();
};
if ($@) {
    warn "Exception when calling DirectoryservicesApi->directoryservicesCacheRefreshGet: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.DirectoryservicesApi()

try: 
    api_instance.directoryservices_cache_refresh_get()
except ApiException as e:
    print("Exception when calling DirectoryservicesApi->directoryservicesCacheRefreshGet: %s\n" % e)

Parameters

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


directoryservicesGetStateGet

`DISABLED` Directory Service is disabled. `FAULTED` Directory Service is enabled, but not HEALTHY. Review logs and generated alert messages to debug the issue causing the service to be in a FAULTED state. `LEAVING` Directory Service is in process of stopping. `JOINING` Directory Service is in process of starting. `HEALTHY` Directory Service is enabled, and last status check has passed.


/directoryservices/get_state

Usage and SDK Samples

curl -X GET -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/directoryservices/get_state"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.DirectoryservicesApi;

import java.io.File;
import java.util.*;

public class DirectoryservicesApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        DirectoryservicesApi apiInstance = new DirectoryservicesApi();
        try {
            apiInstance.directoryservicesGetStateGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling DirectoryservicesApi#directoryservicesGetStateGet");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::DirectoryservicesApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::DirectoryservicesApi->new();

eval { 
    $api_instance->directoryservicesGetStateGet();
};
if ($@) {
    warn "Exception when calling DirectoryservicesApi->directoryservicesGetStateGet: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.DirectoryservicesApi()

try: 
    api_instance.directoryservices_get_state_get()
except ApiException as e:
    print("Exception when calling DirectoryservicesApi->directoryservicesGetStateGet: %s\n" % e)

Parameters

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


Disk

diskGet


/disk

Usage and SDK Samples

curl -X GET -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/disk?limit=&offset=&count=&sort="
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.DiskApi;

import java.io.File;
import java.util.*;

public class DiskApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        DiskApi apiInstance = new DiskApi();
        Integer limit = 56; // Integer | 
        Integer offset = 56; // Integer | 
        Boolean count = true; // Boolean | 
        String sort = sort_example; // String | 
        try {
            apiInstance.diskGet(limit, offset, count, sort);
        } catch (ApiException e) {
            System.err.println("Exception when calling DiskApi#diskGet");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::DiskApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::DiskApi->new();
my $limit = 56; # Integer | 
my $offset = 56; # Integer | 
my $count = true; # Boolean | 
my $sort = sort_example; # String | 

eval { 
    $api_instance->diskGet(limit => $limit, offset => $offset, count => $count, sort => $sort);
};
if ($@) {
    warn "Exception when calling DiskApi->diskGet: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.DiskApi()
limit = 56 # Integer |  (optional)
offset = 56 # Integer |  (optional)
count = true # Boolean |  (optional)
sort = sort_example # String |  (optional)

try: 
    api_instance.disk_get(limit=limit, offset=offset, count=count, sort=sort)
except ApiException as e:
    print("Exception when calling DiskApi->diskGet: %s\n" % e)

Parameters

Query parameters
Name Description
limit
Integer
offset
Integer
count
Boolean
sort
String

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


diskGetEncryptedPost

Get all geli providers It might be an entire disk or a partition of type freebsd-zfs. Before a geli encrypted pool can be imported, disks used in the pool should be decrypted and then pool import can proceed as desired. In that case `unused` can be passed as `true`, to find out which disks are geli encrypted but not being used by active ZFS pools.


/disk/get_encrypted

Usage and SDK Samples

curl -X POST -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/disk/get_encrypted"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.DiskApi;

import java.io.File;
import java.util.*;

public class DiskApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        DiskApi apiInstance = new DiskApi();
        Disk_get_encrypted_0 body = ; // Disk_get_encrypted_0 | 
        try {
            apiInstance.diskGetEncryptedPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling DiskApi#diskGetEncryptedPost");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::DiskApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::DiskApi->new();
my $body = WWW::SwaggerClient::Object::Disk_get_encrypted_0->new(); # Disk_get_encrypted_0 | 

eval { 
    $api_instance->diskGetEncryptedPost(body => $body);
};
if ($@) {
    warn "Exception when calling DiskApi->diskGetEncryptedPost: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.DiskApi()
body =  # Disk_get_encrypted_0 |  (optional)

try: 
    api_instance.disk_get_encrypted_post(body=body)
except ApiException as e:
    print("Exception when calling DiskApi->diskGetEncryptedPost: %s\n" % e)

Parameters

Body parameters
Name Description
body

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


diskGetUnusedPost

Helper method to get all disks that are not in use, either by the boot pool or the user pools.


/disk/get_unused

Usage and SDK Samples

curl -X POST -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/disk/get_unused"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.DiskApi;

import java.io.File;
import java.util.*;

public class DiskApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        DiskApi apiInstance = new DiskApi();
        Boolean body = ; // Boolean | 
        try {
            apiInstance.diskGetUnusedPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling DiskApi#diskGetUnusedPost");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::DiskApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::DiskApi->new();
my $body = WWW::SwaggerClient::Object::Boolean->new(); # Boolean | 

eval { 
    $api_instance->diskGetUnusedPost(body => $body);
};
if ($@) {
    warn "Exception when calling DiskApi->diskGetUnusedPost: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.DiskApi()
body =  # Boolean |  (optional)

try: 
    api_instance.disk_get_unused_post(body=body)
except ApiException as e:
    print("Exception when calling DiskApi->diskGetUnusedPost: %s\n" % e)

Parameters

Body parameters
Name Description
body

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


diskIdIdGet


/disk/id/{id}

Usage and SDK Samples

curl -X GET -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/disk/id/{id}?limit=&offset=&count=&sort="
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.DiskApi;

import java.io.File;
import java.util.*;

public class DiskApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        DiskApi apiInstance = new DiskApi();
        array[null] id = ; // array[null] | 
        Integer limit = 56; // Integer | 
        Integer offset = 56; // Integer | 
        Boolean count = true; // Boolean | 
        String sort = sort_example; // String | 
        try {
            apiInstance.diskIdIdGet(id, limit, offset, count, sort);
        } catch (ApiException e) {
            System.err.println("Exception when calling DiskApi#diskIdIdGet");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::DiskApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::DiskApi->new();
my $id = []; # array[null] | 
my $limit = 56; # Integer | 
my $offset = 56; # Integer | 
my $count = true; # Boolean | 
my $sort = sort_example; # String | 

eval { 
    $api_instance->diskIdIdGet(id => $id, limit => $limit, offset => $offset, count => $count, sort => $sort);
};
if ($@) {
    warn "Exception when calling DiskApi->diskIdIdGet: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.DiskApi()
id =  # array[null] | 
limit = 56 # Integer |  (optional)
offset = 56 # Integer |  (optional)
count = true # Boolean |  (optional)
sort = sort_example # String |  (optional)

try: 
    api_instance.disk_id_id_get(id, limit=limit, offset=offset, count=count, sort=sort)
except ApiException as e:
    print("Exception when calling DiskApi->diskIdIdGet: %s\n" % e)

Parameters

Path parameters
Name Description
id*
array[null]
Required
Query parameters
Name Description
limit
Integer
offset
Integer
count
Boolean
sort
String

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


diskIdIdPut

Update disk of `id`. If extra options need to be passed to SMART which we don't already support, they can be passed by `smartoptions`. `critical`, `informational` and `difference` are integer values on which alerts for SMART are configured if the disk temperature crosses the assigned threshold for each respective attribute. If they are set to null, then SMARTD config values are used as defaults. Email of log level LOG_CRIT is issued when disk temperature crosses `critical`. Email of log level LOG_INFO is issued when disk temperature crosses `informational`. If temperature of a disk changes by `difference` degree Celsius since the last report, SMART reports this.


/disk/id/{id}

Usage and SDK Samples

curl -X PUT -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/disk/id/{id}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.DiskApi;

import java.io.File;
import java.util.*;

public class DiskApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        DiskApi apiInstance = new DiskApi();
        String id = id_example; // String | 
        Disk_update_1 body = ; // Disk_update_1 | 
        try {
            apiInstance.diskIdIdPut(id, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling DiskApi#diskIdIdPut");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::DiskApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::DiskApi->new();
my $id = id_example; # String | 
my $body = WWW::SwaggerClient::Object::Disk_update_1->new(); # Disk_update_1 | 

eval { 
    $api_instance->diskIdIdPut(id => $id, body => $body);
};
if ($@) {
    warn "Exception when calling DiskApi->diskIdIdPut: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.DiskApi()
id = id_example # String | 
body =  # Disk_update_1 |  (optional)

try: 
    api_instance.disk_id_id_put(id, body=body)
except ApiException as e:
    print("Exception when calling DiskApi->diskIdIdPut: %s\n" % e)

Parameters

Path parameters
Name Description
id*
String
Required
Body parameters
Name Description
body

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


diskLabelToDevGet


/disk/label_to_dev

Usage and SDK Samples

curl -X GET -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/disk/label_to_dev"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.DiskApi;

import java.io.File;
import java.util.*;

public class DiskApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        DiskApi apiInstance = new DiskApi();
        try {
            apiInstance.diskLabelToDevGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling DiskApi#diskLabelToDevGet");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::DiskApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::DiskApi->new();

eval { 
    $api_instance->diskLabelToDevGet();
};
if ($@) {
    warn "Exception when calling DiskApi->diskLabelToDevGet: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.DiskApi()

try: 
    api_instance.disk_label_to_dev_get()
except ApiException as e:
    print("Exception when calling DiskApi->diskLabelToDevGet: %s\n" % e)

Parameters

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


diskOverprovisionPost

Sets overprovision of disk `devname` to `size` gigabytes


/disk/overprovision

Usage and SDK Samples

curl -X POST -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/disk/overprovision"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.DiskApi;

import java.io.File;
import java.util.*;

public class DiskApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        DiskApi apiInstance = new DiskApi();
        Disk_overprovision body = ; // Disk_overprovision | 
        try {
            apiInstance.diskOverprovisionPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling DiskApi#diskOverprovisionPost");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::DiskApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::DiskApi->new();
my $body = WWW::SwaggerClient::Object::Disk_overprovision->new(); # Disk_overprovision | 

eval { 
    $api_instance->diskOverprovisionPost(body => $body);
};
if ($@) {
    warn "Exception when calling DiskApi->diskOverprovisionPost: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.DiskApi()
body =  # Disk_overprovision |  (optional)

try: 
    api_instance.disk_overprovision_post(body=body)
except ApiException as e:
    print("Exception when calling DiskApi->diskOverprovisionPost: %s\n" % e)

Parameters

Body parameters
Name Description
body

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


diskSmartAttributesPost

Returns S.M.A.R.T. attributes values for specified disk name.


/disk/smart_attributes

Usage and SDK Samples

curl -X POST -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/disk/smart_attributes"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.DiskApi;

import java.io.File;
import java.util.*;

public class DiskApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        DiskApi apiInstance = new DiskApi();
        String body = ; // String | 
        try {
            apiInstance.diskSmartAttributesPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling DiskApi#diskSmartAttributesPost");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::DiskApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::DiskApi->new();
my $body = WWW::SwaggerClient::Object::String->new(); # String | 

eval { 
    $api_instance->diskSmartAttributesPost(body => $body);
};
if ($@) {
    warn "Exception when calling DiskApi->diskSmartAttributesPost: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.DiskApi()
body =  # String |  (optional)

try: 
    api_instance.disk_smart_attributes_post(body=body)
except ApiException as e:
    print("Exception when calling DiskApi->diskSmartAttributesPost: %s\n" % e)

Parameters

Body parameters
Name Description
body

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


diskSpindownPost

Spin down disk by device name


/disk/spindown

Usage and SDK Samples

curl -X POST -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/disk/spindown"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.DiskApi;

import java.io.File;
import java.util.*;

public class DiskApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        DiskApi apiInstance = new DiskApi();
        String body = ; // String | 
        try {
            apiInstance.diskSpindownPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling DiskApi#diskSpindownPost");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::DiskApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::DiskApi->new();
my $body = WWW::SwaggerClient::Object::String->new(); # String | 

eval { 
    $api_instance->diskSpindownPost(body => $body);
};
if ($@) {
    warn "Exception when calling DiskApi->diskSpindownPost: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.DiskApi()
body =  # String |  (optional)

try: 
    api_instance.disk_spindown_post(body=body)
except ApiException as e:
    print("Exception when calling DiskApi->diskSpindownPost: %s\n" % e)

Parameters

Body parameters
Name Description
body

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


diskTemperaturePost

Returns temperature for device `name` using specified S.M.A.R.T. `powermode`.


/disk/temperature

Usage and SDK Samples

curl -X POST -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/disk/temperature"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.DiskApi;

import java.io.File;
import java.util.*;

public class DiskApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        DiskApi apiInstance = new DiskApi();
        Disk_temperature body = ; // Disk_temperature | 
        try {
            apiInstance.diskTemperaturePost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling DiskApi#diskTemperaturePost");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::DiskApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::DiskApi->new();
my $body = WWW::SwaggerClient::Object::Disk_temperature->new(); # Disk_temperature | 

eval { 
    $api_instance->diskTemperaturePost(body => $body);
};
if ($@) {
    warn "Exception when calling DiskApi->diskTemperaturePost: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.DiskApi()
body =  # Disk_temperature |  (optional)

try: 
    api_instance.disk_temperature_post(body=body)
except ApiException as e:
    print("Exception when calling DiskApi->diskTemperaturePost: %s\n" % e)

Parameters

Body parameters
Name Description
body

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


diskTemperaturesPost

Returns temperatures for a list of devices (runs in parallel). See `disk.temperature` documentation for more details.


/disk/temperatures

Usage and SDK Samples

curl -X POST -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/disk/temperatures"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.DiskApi;

import java.io.File;
import java.util.*;

public class DiskApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        DiskApi apiInstance = new DiskApi();
        Disk_temperatures body = ; // Disk_temperatures | 
        try {
            apiInstance.diskTemperaturesPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling DiskApi#diskTemperaturesPost");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::DiskApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::DiskApi->new();
my $body = WWW::SwaggerClient::Object::Disk_temperatures->new(); # Disk_temperatures | 

eval { 
    $api_instance->diskTemperaturesPost(body => $body);
};
if ($@) {
    warn "Exception when calling DiskApi->diskTemperaturesPost: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.DiskApi()
body =  # Disk_temperatures |  (optional)

try: 
    api_instance.disk_temperatures_post(body=body)
except ApiException as e:
    print("Exception when calling DiskApi->diskTemperaturesPost: %s\n" % e)

Parameters

Body parameters
Name Description
body

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


diskUnoverprovisionPost

Removes overprovisioning of disk `devname`


/disk/unoverprovision

Usage and SDK Samples

curl -X POST -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/disk/unoverprovision"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.DiskApi;

import java.io.File;
import java.util.*;

public class DiskApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        DiskApi apiInstance = new DiskApi();
        String body = ; // String | 
        try {
            apiInstance.diskUnoverprovisionPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling DiskApi#diskUnoverprovisionPost");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::DiskApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::DiskApi->new();
my $body = WWW::SwaggerClient::Object::String->new(); # String | 

eval { 
    $api_instance->diskUnoverprovisionPost(body => $body);
};
if ($@) {
    warn "Exception when calling DiskApi->diskUnoverprovisionPost: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.DiskApi()
body =  # String |  (optional)

try: 
    api_instance.disk_unoverprovision_post(body=body)
except ApiException as e:
    print("Exception when calling DiskApi->diskUnoverprovisionPost: %s\n" % e)

Parameters

Body parameters
Name Description
body

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


diskWipePost

Performs a wipe of a disk `dev`. It can be of the following modes: - QUICK: clean the first few and last megabytes of every partition and disk - FULL: write whole disk with zero's - FULL_RANDOM: write whole disk with random bytes


/disk/wipe

Usage and SDK Samples

curl -X POST -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/disk/wipe"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.DiskApi;

import java.io.File;
import java.util.*;

public class DiskApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        DiskApi apiInstance = new DiskApi();
        Disk_wipe body = ; // Disk_wipe | 
        try {
            apiInstance.diskWipePost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling DiskApi#diskWipePost");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::DiskApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::DiskApi->new();
my $body = WWW::SwaggerClient::Object::Disk_wipe->new(); # Disk_wipe | 

eval { 
    $api_instance->diskWipePost(body => $body);
};
if ($@) {
    warn "Exception when calling DiskApi->diskWipePost: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.DiskApi()
body =  # Disk_wipe |  (optional)

try: 
    api_instance.disk_wipe_post(body=body)
except ApiException as e:
    print("Exception when calling DiskApi->diskWipePost: %s\n" % e)

Parameters

Body parameters
Name Description
body

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


Dns

dnsQueryGet

Query Name Servers with `query-filters` and `query-options`.


/dns/query

Usage and SDK Samples

curl -X GET -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/dns/query?limit=&offset=&count=&sort="
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.DnsApi;

import java.io.File;
import java.util.*;

public class DnsApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        DnsApi apiInstance = new DnsApi();
        Integer limit = 56; // Integer | 
        Integer offset = 56; // Integer | 
        Boolean count = true; // Boolean | 
        String sort = sort_example; // String | 
        try {
            apiInstance.dnsQueryGet(limit, offset, count, sort);
        } catch (ApiException e) {
            System.err.println("Exception when calling DnsApi#dnsQueryGet");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::DnsApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::DnsApi->new();
my $limit = 56; # Integer | 
my $offset = 56; # Integer | 
my $count = true; # Boolean | 
my $sort = sort_example; # String | 

eval { 
    $api_instance->dnsQueryGet(limit => $limit, offset => $offset, count => $count, sort => $sort);
};
if ($@) {
    warn "Exception when calling DnsApi->dnsQueryGet: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.DnsApi()
limit = 56 # Integer |  (optional)
offset = 56 # Integer |  (optional)
count = true # Boolean |  (optional)
sort = sort_example # String |  (optional)

try: 
    api_instance.dns_query_get(limit=limit, offset=offset, count=count, sort=sort)
except ApiException as e:
    print("Exception when calling DnsApi->dnsQueryGet: %s\n" % e)

Parameters

Query parameters
Name Description
limit
Integer
offset
Integer
count
Boolean
sort
String

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


Dyndns

dyndnsGet


/dyndns

Usage and SDK Samples

curl -X GET -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/dyndns"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.DyndnsApi;

import java.io.File;
import java.util.*;

public class DyndnsApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        DyndnsApi apiInstance = new DyndnsApi();
        try {
            apiInstance.dyndnsGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling DyndnsApi#dyndnsGet");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::DyndnsApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::DyndnsApi->new();

eval { 
    $api_instance->dyndnsGet();
};
if ($@) {
    warn "Exception when calling DyndnsApi->dyndnsGet: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.DyndnsApi()

try: 
    api_instance.dyndns_get()
except ApiException as e:
    print("Exception when calling DyndnsApi->dyndnsGet: %s\n" % e)

Parameters

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


dyndnsProviderChoicesGet

List supported Dynamic DNS Service Providers.


/dyndns/provider_choices

Usage and SDK Samples

curl -X GET -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/dyndns/provider_choices"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.DyndnsApi;

import java.io.File;
import java.util.*;

public class DyndnsApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        DyndnsApi apiInstance = new DyndnsApi();
        try {
            apiInstance.dyndnsProviderChoicesGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling DyndnsApi#dyndnsProviderChoicesGet");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::DyndnsApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::DyndnsApi->new();

eval { 
    $api_instance->dyndnsProviderChoicesGet();
};
if ($@) {
    warn "Exception when calling DyndnsApi->dyndnsProviderChoicesGet: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.DyndnsApi()

try: 
    api_instance.dyndns_provider_choices_get()
except ApiException as e:
    print("Exception when calling DyndnsApi->dyndnsProviderChoicesGet: %s\n" % e)

Parameters

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


dyndnsPut

Update dynamic dns service configuration. `period` indicates how often the IP is checked in seconds. `ssl` if set to true, makes sure that HTTPS is used for the connection to the server which updates the DNS record.


/dyndns

Usage and SDK Samples

curl -X PUT -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/dyndns"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.DyndnsApi;

import java.io.File;
import java.util.*;

public class DyndnsApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        DyndnsApi apiInstance = new DyndnsApi();
        Dyndns_update_0 body = ; // Dyndns_update_0 | 
        try {
            apiInstance.dyndnsPut(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling DyndnsApi#dyndnsPut");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::DyndnsApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::DyndnsApi->new();
my $body = WWW::SwaggerClient::Object::Dyndns_update_0->new(); # Dyndns_update_0 | 

eval { 
    $api_instance->dyndnsPut(body => $body);
};
if ($@) {
    warn "Exception when calling DyndnsApi->dyndnsPut: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.DyndnsApi()
body =  # Dyndns_update_0 |  (optional)

try: 
    api_instance.dyndns_put(body=body)
except ApiException as e:
    print("Exception when calling DyndnsApi->dyndnsPut: %s\n" % e)

Parameters

Body parameters
Name Description
body

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


Ec2

ec2InstanceIdGet


/ec2/instance_id

Usage and SDK Samples

curl -X GET -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/ec2/instance_id"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.Ec2Api;

import java.io.File;
import java.util.*;

public class Ec2ApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        Ec2Api apiInstance = new Ec2Api();
        try {
            apiInstance.ec2InstanceIdGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling Ec2Api#ec2InstanceIdGet");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::Ec2Api;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::Ec2Api->new();

eval { 
    $api_instance->ec2InstanceIdGet();
};
if ($@) {
    warn "Exception when calling Ec2Api->ec2InstanceIdGet: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.Ec2Api()

try: 
    api_instance.ec2_instance_id_get()
except ApiException as e:
    print("Exception when calling Ec2Api->ec2InstanceIdGet: %s\n" % e)

Parameters

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


ec2MetaGet


/ec2/Meta

Usage and SDK Samples

curl -X GET -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/ec2/Meta"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.Ec2Api;

import java.io.File;
import java.util.*;

public class Ec2ApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        Ec2Api apiInstance = new Ec2Api();
        try {
            apiInstance.ec2MetaGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling Ec2Api#ec2MetaGet");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::Ec2Api;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::Ec2Api->new();

eval { 
    $api_instance->ec2MetaGet();
};
if ($@) {
    warn "Exception when calling Ec2Api->ec2MetaGet: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.Ec2Api()

try: 
    api_instance.ec2_meta_get()
except ApiException as e:
    print("Exception when calling Ec2Api->ec2MetaGet: %s\n" % e)

Parameters

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


ec2SetNtpServersGet


/ec2/set_ntp_servers

Usage and SDK Samples

curl -X GET -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/ec2/set_ntp_servers"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.Ec2Api;

import java.io.File;
import java.util.*;

public class Ec2ApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        Ec2Api apiInstance = new Ec2Api();
        try {
            apiInstance.ec2SetNtpServersGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling Ec2Api#ec2SetNtpServersGet");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::Ec2Api;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::Ec2Api->new();

eval { 
    $api_instance->ec2SetNtpServersGet();
};
if ($@) {
    warn "Exception when calling Ec2Api->ec2SetNtpServersGet: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.Ec2Api()

try: 
    api_instance.ec2_set_ntp_servers_get()
except ApiException as e:
    print("Exception when calling Ec2Api->ec2SetNtpServersGet: %s\n" % e)

Parameters

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


ec2SetRootSshPublicKeyGet


/ec2/set_root_ssh_public_key

Usage and SDK Samples

curl -X GET -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/ec2/set_root_ssh_public_key"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.Ec2Api;

import java.io.File;
import java.util.*;

public class Ec2ApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        Ec2Api apiInstance = new Ec2Api();
        try {
            apiInstance.ec2SetRootSshPublicKeyGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling Ec2Api#ec2SetRootSshPublicKeyGet");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::Ec2Api;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::Ec2Api->new();

eval { 
    $api_instance->ec2SetRootSshPublicKeyGet();
};
if ($@) {
    warn "Exception when calling Ec2Api->ec2SetRootSshPublicKeyGet: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.Ec2Api()

try: 
    api_instance.ec2_set_root_ssh_public_key_get()
except ApiException as e:
    print("Exception when calling Ec2Api->ec2SetRootSshPublicKeyGet: %s\n" % e)

Parameters

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


ec2SetupGet


/ec2/setup

Usage and SDK Samples

curl -X GET -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/ec2/setup"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.Ec2Api;

import java.io.File;
import java.util.*;

public class Ec2ApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        Ec2Api apiInstance = new Ec2Api();
        try {
            apiInstance.ec2SetupGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling Ec2Api#ec2SetupGet");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::Ec2Api;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::Ec2Api->new();

eval { 
    $api_instance->ec2SetupGet();
};
if ($@) {
    warn "Exception when calling Ec2Api->ec2SetupGet: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.Ec2Api()

try: 
    api_instance.ec2_setup_get()
except ApiException as e:
    print("Exception when calling Ec2Api->ec2SetupGet: %s\n" % e)

Parameters

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


Enclosure

enclosureGet


/enclosure

Usage and SDK Samples

curl -X GET -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/enclosure?limit=&offset=&count=&sort="
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.EnclosureApi;

import java.io.File;
import java.util.*;

public class EnclosureApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        EnclosureApi apiInstance = new EnclosureApi();
        Integer limit = 56; // Integer | 
        Integer offset = 56; // Integer | 
        Boolean count = true; // Boolean | 
        String sort = sort_example; // String | 
        try {
            apiInstance.enclosureGet(limit, offset, count, sort);
        } catch (ApiException e) {
            System.err.println("Exception when calling EnclosureApi#enclosureGet");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::EnclosureApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::EnclosureApi->new();
my $limit = 56; # Integer | 
my $offset = 56; # Integer | 
my $count = true; # Boolean | 
my $sort = sort_example; # String | 

eval { 
    $api_instance->enclosureGet(limit => $limit, offset => $offset, count => $count, sort => $sort);
};
if ($@) {
    warn "Exception when calling EnclosureApi->enclosureGet: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.EnclosureApi()
limit = 56 # Integer |  (optional)
offset = 56 # Integer |  (optional)
count = true # Boolean |  (optional)
sort = sort_example # String |  (optional)

try: 
    api_instance.enclosure_get(limit=limit, offset=offset, count=count, sort=sort)
except ApiException as e:
    print("Exception when calling EnclosureApi->enclosureGet: %s\n" % e)

Parameters

Query parameters
Name Description
limit
Integer
offset
Integer
count
Boolean
sort
String

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


enclosureIdIdGet


/enclosure/id/{id}

Usage and SDK Samples

curl -X GET -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/enclosure/id/{id}?limit=&offset=&count=&sort="
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.EnclosureApi;

import java.io.File;
import java.util.*;

public class EnclosureApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        EnclosureApi apiInstance = new EnclosureApi();
        array[null] id = ; // array[null] | 
        Integer limit = 56; // Integer | 
        Integer offset = 56; // Integer | 
        Boolean count = true; // Boolean | 
        String sort = sort_example; // String | 
        try {
            apiInstance.enclosureIdIdGet(id, limit, offset, count, sort);
        } catch (ApiException e) {
            System.err.println("Exception when calling EnclosureApi#enclosureIdIdGet");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::EnclosureApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::EnclosureApi->new();
my $id = []; # array[null] | 
my $limit = 56; # Integer | 
my $offset = 56; # Integer | 
my $count = true; # Boolean | 
my $sort = sort_example; # String | 

eval { 
    $api_instance->enclosureIdIdGet(id => $id, limit => $limit, offset => $offset, count => $count, sort => $sort);
};
if ($@) {
    warn "Exception when calling EnclosureApi->enclosureIdIdGet: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.EnclosureApi()
id =  # array[null] | 
limit = 56 # Integer |  (optional)
offset = 56 # Integer |  (optional)
count = true # Boolean |  (optional)
sort = sort_example # String |  (optional)

try: 
    api_instance.enclosure_id_id_get(id, limit=limit, offset=offset, count=count, sort=sort)
except ApiException as e:
    print("Exception when calling EnclosureApi->enclosureIdIdGet: %s\n" % e)

Parameters

Path parameters
Name Description
id*
array[null]
Required
Query parameters
Name Description
limit
Integer
offset
Integer
count
Boolean
sort
String

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


enclosureIdIdPut


/enclosure/id/{id}

Usage and SDK Samples

curl -X PUT -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/enclosure/id/{id}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.EnclosureApi;

import java.io.File;
import java.util.*;

public class EnclosureApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        EnclosureApi apiInstance = new EnclosureApi();
        String id = id_example; // String | 
        Enclosure_update_1 body = ; // Enclosure_update_1 | 
        try {
            apiInstance.enclosureIdIdPut(id, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling EnclosureApi#enclosureIdIdPut");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::EnclosureApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::EnclosureApi->new();
my $id = id_example; # String | 
my $body = WWW::SwaggerClient::Object::Enclosure_update_1->new(); # Enclosure_update_1 | 

eval { 
    $api_instance->enclosureIdIdPut(id => $id, body => $body);
};
if ($@) {
    warn "Exception when calling EnclosureApi->enclosureIdIdPut: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.EnclosureApi()
id = id_example # String | 
body =  # Enclosure_update_1 |  (optional)

try: 
    api_instance.enclosure_id_id_put(id, body=body)
except ApiException as e:
    print("Exception when calling EnclosureApi->enclosureIdIdPut: %s\n" % e)

Parameters

Path parameters
Name Description
id*
String
Required
Body parameters
Name Description
body

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


enclosureSetSlotStatusPost


/enclosure/set_slot_status

Usage and SDK Samples

curl -X POST -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/enclosure/set_slot_status"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.EnclosureApi;

import java.io.File;
import java.util.*;

public class EnclosureApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        EnclosureApi apiInstance = new EnclosureApi();
        Enclosure_set_slot_status body = ; // Enclosure_set_slot_status | 
        try {
            apiInstance.enclosureSetSlotStatusPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling EnclosureApi#enclosureSetSlotStatusPost");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::EnclosureApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::EnclosureApi->new();
my $body = WWW::SwaggerClient::Object::Enclosure_set_slot_status->new(); # Enclosure_set_slot_status | 

eval { 
    $api_instance->enclosureSetSlotStatusPost(body => $body);
};
if ($@) {
    warn "Exception when calling EnclosureApi->enclosureSetSlotStatusPost: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.EnclosureApi()
body =  # Enclosure_set_slot_status |  (optional)

try: 
    api_instance.enclosure_set_slot_status_post(body=body)
except ApiException as e:
    print("Exception when calling EnclosureApi->enclosureSetSlotStatusPost: %s\n" % e)

Parameters

Body parameters
Name Description
body

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


Failover

failoverCallRemotePost

Call a method in the other node.


/failover/call_remote

Usage and SDK Samples

curl -X POST -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/failover/call_remote"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.FailoverApi;

import java.io.File;
import java.util.*;

public class FailoverApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        FailoverApi apiInstance = new FailoverApi();
        Failover_call_remote body = ; // Failover_call_remote | 
        try {
            apiInstance.failoverCallRemotePost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling FailoverApi#failoverCallRemotePost");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::FailoverApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::FailoverApi->new();
my $body = WWW::SwaggerClient::Object::Failover_call_remote->new(); # Failover_call_remote | 

eval { 
    $api_instance->failoverCallRemotePost(body => $body);
};
if ($@) {
    warn "Exception when calling FailoverApi->failoverCallRemotePost: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.FailoverApi()
body =  # Failover_call_remote |  (optional)

try: 
    api_instance.failover_call_remote_post(body=body)
except ApiException as e:
    print("Exception when calling FailoverApi->failoverCallRemotePost: %s\n" % e)

Parameters

Body parameters
Name Description
body

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


failoverControlPost


/failover/control

Usage and SDK Samples

curl -X POST -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/failover/control"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.FailoverApi;

import java.io.File;
import java.util.*;

public class FailoverApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        FailoverApi apiInstance = new FailoverApi();
        Failover_control body = ; // Failover_control | 
        try {
            apiInstance.failoverControlPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling FailoverApi#failoverControlPost");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::FailoverApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::FailoverApi->new();
my $body = WWW::SwaggerClient::Object::Failover_control->new(); # Failover_control | 

eval { 
    $api_instance->failoverControlPost(body => $body);
};
if ($@) {
    warn "Exception when calling FailoverApi->failoverControlPost: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.FailoverApi()
body =  # Failover_control |  (optional)

try: 
    api_instance.failover_control_post(body=body)
except ApiException as e:
    print("Exception when calling FailoverApi->failoverControlPost: %s\n" % e)

Parameters

Body parameters
Name Description
body

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


failoverForceMasterGet

Force this controller to become MASTER.


/failover/force_master

Usage and SDK Samples

curl -X GET -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/failover/force_master"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.FailoverApi;

import java.io.File;
import java.util.*;

public class FailoverApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        FailoverApi apiInstance = new FailoverApi();
        try {
            apiInstance.failoverForceMasterGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling FailoverApi#failoverForceMasterGet");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::FailoverApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::FailoverApi->new();

eval { 
    $api_instance->failoverForceMasterGet();
};
if ($@) {
    warn "Exception when calling FailoverApi->failoverForceMasterGet: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.FailoverApi()

try: 
    api_instance.failover_force_master_get()
except ApiException as e:
    print("Exception when calling FailoverApi->failoverForceMasterGet: %s\n" % e)

Parameters

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


failoverGet


/failover

Usage and SDK Samples

curl -X GET -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/failover"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.FailoverApi;

import java.io.File;
import java.util.*;

public class FailoverApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        FailoverApi apiInstance = new FailoverApi();
        try {
            apiInstance.failoverGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling FailoverApi#failoverGet");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::FailoverApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::FailoverApi->new();

eval { 
    $api_instance->failoverGet();
};
if ($@) {
    warn "Exception when calling FailoverApi->failoverGet: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.FailoverApi()

try: 
    api_instance.failover_get()
except ApiException as e:
    print("Exception when calling FailoverApi->failoverGet: %s\n" % e)

Parameters

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


failoverHardwareGet

Returns the hardware type for an HA system. ECHOSTREAM ECHOWARP PUMA SBB ULTIMATE BHYVE MANUAL


/failover/hardware

Usage and SDK Samples

curl -X GET -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/failover/hardware"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.FailoverApi;

import java.io.File;
import java.util.*;

public class FailoverApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        FailoverApi apiInstance = new FailoverApi();
        try {
            apiInstance.failoverHardwareGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling FailoverApi#failoverHardwareGet");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::FailoverApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::FailoverApi->new();

eval { 
    $api_instance->failoverHardwareGet();
};
if ($@) {
    warn "Exception when calling FailoverApi->failoverHardwareGet: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.FailoverApi()

try: 
    api_instance.failover_hardware_get()
except ApiException as e:
    print("Exception when calling FailoverApi->failoverHardwareGet: %s\n" % e)

Parameters

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


failoverInProgressGet

Returns True if there is an ongoing failover event.


/failover/in_progress

Usage and SDK Samples

curl -X GET -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/failover/in_progress"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.FailoverApi;

import java.io.File;
import java.util.*;

public class FailoverApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        FailoverApi apiInstance = new FailoverApi();
        try {
            apiInstance.failoverInProgressGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling FailoverApi#failoverInProgressGet");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::FailoverApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::FailoverApi->new();

eval { 
    $api_instance->failoverInProgressGet();
};
if ($@) {
    warn "Exception when calling FailoverApi->failoverInProgressGet: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.FailoverApi()

try: 
    api_instance.failover_in_progress_get()
except ApiException as e:
    print("Exception when calling FailoverApi->failoverInProgressGet: %s\n" % e)

Parameters

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


failoverLicensedGet

Checks whether this instance is licensed as a HA unit.


/failover/licensed

Usage and SDK Samples

curl -X GET -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/failover/licensed"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.FailoverApi;

import java.io.File;
import java.util.*;

public class FailoverApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        FailoverApi apiInstance = new FailoverApi();
        try {
            apiInstance.failoverLicensedGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling FailoverApi#failoverLicensedGet");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::FailoverApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::FailoverApi->new();

eval { 
    $api_instance->failoverLicensedGet();
};
if ($@) {
    warn "Exception when calling FailoverApi->failoverLicensedGet: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.FailoverApi()

try: 
    api_instance.failover_licensed_get()
except ApiException as e:
    print("Exception when calling FailoverApi->failoverLicensedGet: %s\n" % e)

Parameters

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


failoverNodeGet

Returns the slot position in the chassis that the controller is located. A - First node B - Seconde Node MANUAL - slot position in chassis could not be determined


/failover/node

Usage and SDK Samples

curl -X GET -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/failover/node"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.FailoverApi;

import java.io.File;
import java.util.*;

public class FailoverApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        FailoverApi apiInstance = new FailoverApi();
        try {
            apiInstance.failoverNodeGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling FailoverApi#failoverNodeGet");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::FailoverApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::FailoverApi->new();

eval { 
    $api_instance->failoverNodeGet();
};
if ($@) {
    warn "Exception when calling FailoverApi->failoverNodeGet: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.FailoverApi()

try: 
    api_instance.failover_node_get()
except ApiException as e:
    print("Exception when calling FailoverApi->failoverNodeGet: %s\n" % e)

Parameters

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


failoverPut

Update failover state. `disabled` when true indicates that HA is disabled. `master` sets the state of current node. Standby node will have the opposite value. `timeout` is the time to WAIT until a failover occurs when a network event occurs on an interface that is marked critical for failover AND HA is enabled and working appropriately. The default time to wait is 2 seconds. **NOTE** This setting does NOT effect the `disabled` or `master` parameters.


/failover

Usage and SDK Samples

curl -X PUT -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/failover"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.FailoverApi;

import java.io.File;
import java.util.*;

public class FailoverApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        FailoverApi apiInstance = new FailoverApi();
        Failover_update_0 body = ; // Failover_update_0 | 
        try {
            apiInstance.failoverPut(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling FailoverApi#failoverPut");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::FailoverApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::FailoverApi->new();
my $body = WWW::SwaggerClient::Object::Failover_update_0->new(); # Failover_update_0 | 

eval { 
    $api_instance->failoverPut(body => $body);
};
if ($@) {
    warn "Exception when calling FailoverApi->failoverPut: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.FailoverApi()
body =  # Failover_update_0 |  (optional)

try: 
    api_instance.failover_put(body=body)
except ApiException as e:
    print("Exception when calling FailoverApi->failoverPut: %s\n" % e)

Parameters

Body parameters
Name Description
body

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


failoverSyncFromPeerGet

Sync database and files from the other controller.


/failover/sync_from_peer

Usage and SDK Samples

curl -X GET -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/failover/sync_from_peer"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.FailoverApi;

import java.io.File;
import java.util.*;

public class FailoverApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        FailoverApi apiInstance = new FailoverApi();
        try {
            apiInstance.failoverSyncFromPeerGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling FailoverApi#failoverSyncFromPeerGet");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::FailoverApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::FailoverApi->new();

eval { 
    $api_instance->failoverSyncFromPeerGet();
};
if ($@) {
    warn "Exception when calling FailoverApi->failoverSyncFromPeerGet: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.FailoverApi()

try: 
    api_instance.failover_sync_from_peer_get()
except ApiException as e:
    print("Exception when calling FailoverApi->failoverSyncFromPeerGet: %s\n" % e)

Parameters

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


failoverSyncToPeerPost

Sync database and files to the other controller. `reboot` as true will reboot the other controller after syncing.


/failover/sync_to_peer

Usage and SDK Samples

curl -X POST -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/failover/sync_to_peer"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.FailoverApi;

import java.io.File;
import java.util.*;

public class FailoverApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        FailoverApi apiInstance = new FailoverApi();
        Failover_sync_to_peer_0 body = ; // Failover_sync_to_peer_0 | 
        try {
            apiInstance.failoverSyncToPeerPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling FailoverApi#failoverSyncToPeerPost");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::FailoverApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::FailoverApi->new();
my $body = WWW::SwaggerClient::Object::Failover_sync_to_peer_0->new(); # Failover_sync_to_peer_0 | 

eval { 
    $api_instance->failoverSyncToPeerPost(body => $body);
};
if ($@) {
    warn "Exception when calling FailoverApi->failoverSyncToPeerPost: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.FailoverApi()
body =  # Failover_sync_to_peer_0 |  (optional)

try: 
    api_instance.failover_sync_to_peer_post(body=body)
except ApiException as e:
    print("Exception when calling FailoverApi->failoverSyncToPeerPost: %s\n" % e)

Parameters

Body parameters
Name Description
body

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


failoverUnlockPost

Unlock pools in HA, syncing passphrase between controllers and forcing this controller to be MASTER importing the pools.


/failover/unlock

Usage and SDK Samples

curl -X POST -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/failover/unlock"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.FailoverApi;

import java.io.File;
import java.util.*;

public class FailoverApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        FailoverApi apiInstance = new FailoverApi();
        Failover_unlock_0 body = ; // Failover_unlock_0 | 
        try {
            apiInstance.failoverUnlockPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling FailoverApi#failoverUnlockPost");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::FailoverApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::FailoverApi->new();
my $body = WWW::SwaggerClient::Object::Failover_unlock_0->new(); # Failover_unlock_0 | 

eval { 
    $api_instance->failoverUnlockPost(body => $body);
};
if ($@) {
    warn "Exception when calling FailoverApi->failoverUnlockPost: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.FailoverApi()
body =  # Failover_unlock_0 |  (optional)

try: 
    api_instance.failover_unlock_post(body=body)
except ApiException as e:
    print("Exception when calling FailoverApi->failoverUnlockPost: %s\n" % e)

Parameters

Body parameters
Name Description
body

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


failoverUpgradeFinishGet

Perform the last stage of an HA upgrade. This will activate the new boot environment on the Standby Controller and reboot it.


/failover/upgrade_finish

Usage and SDK Samples

curl -X GET -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/failover/upgrade_finish"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.FailoverApi;

import java.io.File;
import java.util.*;

public class FailoverApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        FailoverApi apiInstance = new FailoverApi();
        try {
            apiInstance.failoverUpgradeFinishGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling FailoverApi#failoverUpgradeFinishGet");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::FailoverApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::FailoverApi->new();

eval { 
    $api_instance->failoverUpgradeFinishGet();
};
if ($@) {
    warn "Exception when calling FailoverApi->failoverUpgradeFinishGet: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.FailoverApi()

try: 
    api_instance.failover_upgrade_finish_get()
except ApiException as e:
    print("Exception when calling FailoverApi->failoverUpgradeFinishGet: %s\n" % e)

Parameters

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


failoverUpgradePendingGet

Verify if HA upgrade is pending. `upgrade_finish` needs to be called to finish the HA upgrade process if this method returns true.


/failover/upgrade_pending

Usage and SDK Samples

curl -X GET -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/failover/upgrade_pending"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.FailoverApi;

import java.io.File;
import java.util.*;

public class FailoverApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        FailoverApi apiInstance = new FailoverApi();
        try {
            apiInstance.failoverUpgradePendingGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling FailoverApi#failoverUpgradePendingGet");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::FailoverApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::FailoverApi->new();

eval { 
    $api_instance->failoverUpgradePendingGet();
};
if ($@) {
    warn "Exception when calling FailoverApi->failoverUpgradePendingGet: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.FailoverApi()

try: 
    api_instance.failover_upgrade_pending_get()
except ApiException as e:
    print("Exception when calling FailoverApi->failoverUpgradePendingGet: %s\n" % e)

Parameters

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


failoverUpgradePost

Upgrades both controllers. Files will be downloaded to the Active Controller and then transferred to the Standby Controller. Upgrade process will start concurrently on both nodes. Once both upgrades are applied, the Standby Controller will reboot. This job will wait for that job to complete before finalizing. A file can be uploaded to this end point. This end point is special, please refer to Jobs section in Websocket API documentation for details.


/failover/upgrade

Usage and SDK Samples

curl -X POST -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/failover/upgrade"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.FailoverApi;

import java.io.File;
import java.util.*;

public class FailoverApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        FailoverApi apiInstance = new FailoverApi();
        Failover_upgrade_0 body = ; // Failover_upgrade_0 | 
        try {
            apiInstance.failoverUpgradePost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling FailoverApi#failoverUpgradePost");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::FailoverApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::FailoverApi->new();
my $body = WWW::SwaggerClient::Object::Failover_upgrade_0->new(); # Failover_upgrade_0 | 

eval { 
    $api_instance->failoverUpgradePost(body => $body);
};
if ($@) {
    warn "Exception when calling FailoverApi->failoverUpgradePost: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.FailoverApi()
body =  # Failover_upgrade_0 |  (optional)

try: 
    api_instance.failover_upgrade_post(body=body)
except ApiException as e:
    print("Exception when calling FailoverApi->failoverUpgradePost: %s\n" % e)

Parameters

Body parameters
Name Description
body

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


Fcport

fcportGet


/fcport

Usage and SDK Samples

curl -X GET -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/fcport?limit=&offset=&count=&sort="
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.FcportApi;

import java.io.File;
import java.util.*;

public class FcportApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        FcportApi apiInstance = new FcportApi();
        Integer limit = 56; // Integer | 
        Integer offset = 56; // Integer | 
        Boolean count = true; // Boolean | 
        String sort = sort_example; // String | 
        try {
            apiInstance.fcportGet(limit, offset, count, sort);
        } catch (ApiException e) {
            System.err.println("Exception when calling FcportApi#fcportGet");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::FcportApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::FcportApi->new();
my $limit = 56; # Integer | 
my $offset = 56; # Integer | 
my $count = true; # Boolean | 
my $sort = sort_example; # String | 

eval { 
    $api_instance->fcportGet(limit => $limit, offset => $offset, count => $count, sort => $sort);
};
if ($@) {
    warn "Exception when calling FcportApi->fcportGet: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.FcportApi()
limit = 56 # Integer |  (optional)
offset = 56 # Integer |  (optional)
count = true # Boolean |  (optional)
sort = sort_example # String |  (optional)

try: 
    api_instance.fcport_get(limit=limit, offset=offset, count=count, sort=sort)
except ApiException as e:
    print("Exception when calling FcportApi->fcportGet: %s\n" % e)

Parameters

Query parameters
Name Description
limit
Integer
offset
Integer
count
Boolean
sort
String

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


fcportIdIdGet


/fcport/id/{id}

Usage and SDK Samples

curl -X GET -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/fcport/id/{id}?limit=&offset=&count=&sort="
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.FcportApi;

import java.io.File;
import java.util.*;

public class FcportApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        FcportApi apiInstance = new FcportApi();
        array[null] id = ; // array[null] | 
        Integer limit = 56; // Integer | 
        Integer offset = 56; // Integer | 
        Boolean count = true; // Boolean | 
        String sort = sort_example; // String | 
        try {
            apiInstance.fcportIdIdGet(id, limit, offset, count, sort);
        } catch (ApiException e) {
            System.err.println("Exception when calling FcportApi#fcportIdIdGet");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::FcportApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::FcportApi->new();
my $id = []; # array[null] | 
my $limit = 56; # Integer | 
my $offset = 56; # Integer | 
my $count = true; # Boolean | 
my $sort = sort_example; # String | 

eval { 
    $api_instance->fcportIdIdGet(id => $id, limit => $limit, offset => $offset, count => $count, sort => $sort);
};
if ($@) {
    warn "Exception when calling FcportApi->fcportIdIdGet: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.FcportApi()
id =  # array[null] | 
limit = 56 # Integer |  (optional)
offset = 56 # Integer |  (optional)
count = true # Boolean |  (optional)
sort = sort_example # String |  (optional)

try: 
    api_instance.fcport_id_id_get(id, limit=limit, offset=offset, count=count, sort=sort)
except ApiException as e:
    print("Exception when calling FcportApi->fcportIdIdGet: %s\n" % e)

Parameters

Path parameters
Name Description
id*
array[null]
Required
Query parameters
Name Description
limit
Integer
offset
Integer
count
Boolean
sort
String

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


fcportIdIdPut


/fcport/id/{id}

Usage and SDK Samples

curl -X PUT -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/fcport/id/{id}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.FcportApi;

import java.io.File;
import java.util.*;

public class FcportApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        FcportApi apiInstance = new FcportApi();
        String id = id_example; // String | 
        Fcport_update_1 body = ; // Fcport_update_1 | 
        try {
            apiInstance.fcportIdIdPut(id, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling FcportApi#fcportIdIdPut");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::FcportApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::FcportApi->new();
my $id = id_example; # String | 
my $body = WWW::SwaggerClient::Object::Fcport_update_1->new(); # Fcport_update_1 | 

eval { 
    $api_instance->fcportIdIdPut(id => $id, body => $body);
};
if ($@) {
    warn "Exception when calling FcportApi->fcportIdIdPut: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.FcportApi()
id = id_example # String | 
body =  # Fcport_update_1 |  (optional)

try: 
    api_instance.fcport_id_id_put(id, body=body)
except ApiException as e:
    print("Exception when calling FcportApi->fcportIdIdPut: %s\n" % e)

Parameters

Path parameters
Name Description
id*
String
Required
Body parameters
Name Description
body

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


Filesystem

filesystemAclIsTrivialPost

Returns True if the ACL can be fully expressed as a file mode without losing any access rules, or if the path does not support NFSv4 ACLs (for example a path on a tmpfs filesystem).


/filesystem/acl_is_trivial

Usage and SDK Samples

curl -X POST -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/filesystem/acl_is_trivial"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.FilesystemApi;

import java.io.File;
import java.util.*;

public class FilesystemApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        FilesystemApi apiInstance = new FilesystemApi();
        String body = ; // String | 
        try {
            apiInstance.filesystemAclIsTrivialPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling FilesystemApi#filesystemAclIsTrivialPost");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::FilesystemApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::FilesystemApi->new();
my $body = WWW::SwaggerClient::Object::String->new(); # String | 

eval { 
    $api_instance->filesystemAclIsTrivialPost(body => $body);
};
if ($@) {
    warn "Exception when calling FilesystemApi->filesystemAclIsTrivialPost: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.FilesystemApi()
body =  # String |  (optional)

try: 
    api_instance.filesystem_acl_is_trivial_post(body=body)
except ApiException as e:
    print("Exception when calling FilesystemApi->filesystemAclIsTrivialPost: %s\n" % e)

Parameters

Body parameters
Name Description
body

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


filesystemChownPost

Change owner or group of file at `path`. `uid` and `gid` specify new owner of the file. If either key is absent or None, then existing value on the file is not changed. `recursive` performs action recursively, but does not traverse filesystem mount points. If `traverse` and `recursive` are specified, then the chown operation will traverse filesystem mount points.


/filesystem/chown

Usage and SDK Samples

curl -X POST -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/filesystem/chown"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.FilesystemApi;

import java.io.File;
import java.util.*;

public class FilesystemApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        FilesystemApi apiInstance = new FilesystemApi();
        Filesystem_chown_0 body = ; // Filesystem_chown_0 | 
        try {
            apiInstance.filesystemChownPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling FilesystemApi#filesystemChownPost");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::FilesystemApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::FilesystemApi->new();
my $body = WWW::SwaggerClient::Object::Filesystem_chown_0->new(); # Filesystem_chown_0 | 

eval { 
    $api_instance->filesystemChownPost(body => $body);
};
if ($@) {
    warn "Exception when calling FilesystemApi->filesystemChownPost: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.FilesystemApi()
body =  # Filesystem_chown_0 |  (optional)

try: 
    api_instance.filesystem_chown_post(body=body)
except ApiException as e:
    print("Exception when calling FilesystemApi->filesystemChownPost: %s\n" % e)

Parameters

Body parameters
Name Description
body

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


filesystemDefaultAclChoicesGet

Get list of default ACL types.


/filesystem/default_acl_choices

Usage and SDK Samples

curl -X GET -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/filesystem/default_acl_choices"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.FilesystemApi;

import java.io.File;
import java.util.*;

public class FilesystemApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        FilesystemApi apiInstance = new FilesystemApi();
        try {
            apiInstance.filesystemDefaultAclChoicesGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling FilesystemApi#filesystemDefaultAclChoicesGet");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::FilesystemApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::FilesystemApi->new();

eval { 
    $api_instance->filesystemDefaultAclChoicesGet();
};
if ($@) {
    warn "Exception when calling FilesystemApi->filesystemDefaultAclChoicesGet: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.FilesystemApi()

try: 
    api_instance.filesystem_default_acl_choices_get()
except ApiException as e:
    print("Exception when calling FilesystemApi->filesystemDefaultAclChoicesGet: %s\n" % e)

Parameters

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


filesystemGetDefaultAclPost

Returns a default ACL depending on the usage specified by `acl_type`. If an admin group is defined, then an entry granting it full control will be placed at the top of the ACL. Optionally may pass `share_type` to argument to get share-specific template ACL.


/filesystem/get_default_acl

Usage and SDK Samples

curl -X POST -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/filesystem/get_default_acl"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.FilesystemApi;

import java.io.File;
import java.util.*;

public class FilesystemApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        FilesystemApi apiInstance = new FilesystemApi();
        Filesystem_get_default_acl body = ; // Filesystem_get_default_acl | 
        try {
            apiInstance.filesystemGetDefaultAclPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling FilesystemApi#filesystemGetDefaultAclPost");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::FilesystemApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::FilesystemApi->new();
my $body = WWW::SwaggerClient::Object::Filesystem_get_default_acl->new(); # Filesystem_get_default_acl | 

eval { 
    $api_instance->filesystemGetDefaultAclPost(body => $body);
};
if ($@) {
    warn "Exception when calling FilesystemApi->filesystemGetDefaultAclPost: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.FilesystemApi()
body =  # Filesystem_get_default_acl |  (optional)

try: 
    api_instance.filesystem_get_default_acl_post(body=body)
except ApiException as e:
    print("Exception when calling FilesystemApi->filesystemGetDefaultAclPost: %s\n" % e)

Parameters

Body parameters
Name Description
body

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


filesystemGetaclPost

Return ACL of a given path. This may return a POSIX1e ACL or a NFSv4 ACL. The acl type is indicated by the `ACLType` key. Errata about ACLType NFSv4: `simplified` returns a shortened form of the ACL permset and flags. `TRAVERSE` sufficient rights to traverse a directory, but not read contents. `READ` sufficient rights to traverse a directory, and read file contents. `MODIFIY` sufficient rights to traverse, read, write, and modify a file. Equivalent to modify_set. `FULL_CONTROL` all permissions. If the permisssions do not fit within one of the pre-defined simplified permissions types, then the full ACL entry will be returned. In all cases we replace USER_OBJ, GROUP_OBJ, and EVERYONE with owner@, group@, everyone@ for consistency with getfacl and setfacl. If one of aforementioned special tags is used, 'id' must be set to None. An inheriting empty everyone@ ACE is appended to non-trivial ACLs in order to enforce Windows expectations regarding permissions inheritance. This entry is removed from NT ACL returned to SMB clients when 'ixnas' samba VFS module is enabled. We also remove it here to avoid confusion.


/filesystem/getacl

Usage and SDK Samples

curl -X POST -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/filesystem/getacl"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.FilesystemApi;

import java.io.File;
import java.util.*;

public class FilesystemApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        FilesystemApi apiInstance = new FilesystemApi();
        Filesystem_getacl body = ; // Filesystem_getacl | 
        try {
            apiInstance.filesystemGetaclPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling FilesystemApi#filesystemGetaclPost");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::FilesystemApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::FilesystemApi->new();
my $body = WWW::SwaggerClient::Object::Filesystem_getacl->new(); # Filesystem_getacl | 

eval { 
    $api_instance->filesystemGetaclPost(body => $body);
};
if ($@) {
    warn "Exception when calling FilesystemApi->filesystemGetaclPost: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.FilesystemApi()
body =  # Filesystem_getacl |  (optional)

try: 
    api_instance.filesystem_getacl_post(body=body)
except ApiException as e:
    print("Exception when calling FilesystemApi->filesystemGetaclPost: %s\n" % e)

Parameters

Body parameters
Name Description
body

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


filesystemListdirPost

Get the contents of a directory. Each entry of the list consists of: name(str): name of the file path(str): absolute path of the entry realpath(str): absolute real path of the entry (if SYMLINK) type(str): DIRECTORY | FILESYSTEM | SYMLINK | OTHER size(int): size of the entry mode(int): file mode/permission uid(int): user id of entry owner gid(int): group id of entry onwer acl(bool): extended ACL is present on file


/filesystem/listdir

Usage and SDK Samples

curl -X POST -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/filesystem/listdir"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.FilesystemApi;

import java.io.File;
import java.util.*;

public class FilesystemApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        FilesystemApi apiInstance = new FilesystemApi();
        Filesystem_listdir body = ; // Filesystem_listdir | 
        try {
            apiInstance.filesystemListdirPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling FilesystemApi#filesystemListdirPost");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::FilesystemApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::FilesystemApi->new();
my $body = WWW::SwaggerClient::Object::Filesystem_listdir->new(); # Filesystem_listdir | 

eval { 
    $api_instance->filesystemListdirPost(body => $body);
};
if ($@) {
    warn "Exception when calling FilesystemApi->filesystemListdirPost: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.FilesystemApi()
body =  # Filesystem_listdir |  (optional)

try: 
    api_instance.filesystem_listdir_post(body=body)
except ApiException as e:
    print("Exception when calling FilesystemApi->filesystemListdirPost: %s\n" % e)

Parameters

Body parameters
Name Description
body

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


filesystemSetaclPost

Set ACL of a given path. Takes the following parameters: `path` full path to directory or file. `dacl` "simplified" ACL here or a full ACL. `uid` the desired UID of the file user. If set to None (the default), then user is not changed. `gid` the desired GID of the file group. If set to None (the default), then group is not changed. `recursive` apply the ACL recursively `traverse` traverse filestem boundaries (ZFS datasets) `strip` convert ACL to trivial. ACL is trivial if it can be expressed as a file mode without losing any access rules. `canonicalize` reorder ACL entries so that they are in concanical form as described in the Microsoft documentation MS-DTYP 2.4.5 (ACL) In all cases we replace USER_OBJ, GROUP_OBJ, and EVERYONE with owner@, group@, everyone@ for consistency with getfacl and setfacl. If one of aforementioned special tags is used, 'id' must be set to None. An inheriting empty everyone@ ACE is appended to non-trivial ACLs in order to enforce Windows expectations regarding permissions inheritance. This entry is removed from NT ACL returned to SMB clients when 'ixnas' samba VFS module is enabled.


/filesystem/setacl

Usage and SDK Samples

curl -X POST -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/filesystem/setacl"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.FilesystemApi;

import java.io.File;
import java.util.*;

public class FilesystemApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        FilesystemApi apiInstance = new FilesystemApi();
        Filesystem_setacl_0 body = ; // Filesystem_setacl_0 | 
        try {
            apiInstance.filesystemSetaclPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling FilesystemApi#filesystemSetaclPost");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::FilesystemApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::FilesystemApi->new();
my $body = WWW::SwaggerClient::Object::Filesystem_setacl_0->new(); # Filesystem_setacl_0 | 

eval { 
    $api_instance->filesystemSetaclPost(body => $body);
};
if ($@) {
    warn "Exception when calling FilesystemApi->filesystemSetaclPost: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.FilesystemApi()
body =  # Filesystem_setacl_0 |  (optional)

try: 
    api_instance.filesystem_setacl_post(body=body)
except ApiException as e:
    print("Exception when calling FilesystemApi->filesystemSetaclPost: %s\n" % e)

Parameters

Body parameters
Name Description
body

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


filesystemSetpermPost

Remove extended ACL from specified path. If `mode` is specified then the mode will be applied to the path and files and subdirectories depending on which `options` are selected. Mode should be formatted as string representation of octal permissions bits. `uid` the desired UID of the file user. If set to None (the default), then user is not changed. `gid` the desired GID of the file group. If set to None (the default), then group is not changed. `stripacl` setperm will fail if an extended ACL is present on `path`, unless `stripacl` is set to True. `recursive` remove ACLs recursively, but do not traverse dataset boundaries. `traverse` remove ACLs from child datasets. If no `mode` is set, and `stripacl` is True, then non-trivial ACLs will be converted to trivial ACLs. An ACL is trivial if it can be expressed as a file mode without losing any access rules.


/filesystem/setperm

Usage and SDK Samples

curl -X POST -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/filesystem/setperm"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.FilesystemApi;

import java.io.File;
import java.util.*;

public class FilesystemApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        FilesystemApi apiInstance = new FilesystemApi();
        Filesystem_setperm_0 body = ; // Filesystem_setperm_0 | 
        try {
            apiInstance.filesystemSetpermPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling FilesystemApi#filesystemSetpermPost");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::FilesystemApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::FilesystemApi->new();
my $body = WWW::SwaggerClient::Object::Filesystem_setperm_0->new(); # Filesystem_setperm_0 | 

eval { 
    $api_instance->filesystemSetpermPost(body => $body);
};
if ($@) {
    warn "Exception when calling FilesystemApi->filesystemSetpermPost: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.FilesystemApi()
body =  # Filesystem_setperm_0 |  (optional)

try: 
    api_instance.filesystem_setperm_post(body=body)
except ApiException as e:
    print("Exception when calling FilesystemApi->filesystemSetpermPost: %s\n" % e)

Parameters

Body parameters
Name Description
body

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


filesystemStatPost

Return the filesystem stat(2) for a given `path`.


/filesystem/stat

Usage and SDK Samples

curl -X POST -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/filesystem/stat"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.FilesystemApi;

import java.io.File;
import java.util.*;

public class FilesystemApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        FilesystemApi apiInstance = new FilesystemApi();
        String body = ; // String | 
        try {
            apiInstance.filesystemStatPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling FilesystemApi#filesystemStatPost");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::FilesystemApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::FilesystemApi->new();
my $body = WWW::SwaggerClient::Object::String->new(); # String | 

eval { 
    $api_instance->filesystemStatPost(body => $body);
};
if ($@) {
    warn "Exception when calling FilesystemApi->filesystemStatPost: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.FilesystemApi()
body =  # String |  (optional)

try: 
    api_instance.filesystem_stat_post(body=body)
except ApiException as e:
    print("Exception when calling FilesystemApi->filesystemStatPost: %s\n" % e)

Parameters

Body parameters
Name Description
body

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


filesystemStatfsPost

Return stats from the filesystem of a given path. Raises: CallError(ENOENT) - Path not found


/filesystem/statfs

Usage and SDK Samples

curl -X POST -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/filesystem/statfs"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.FilesystemApi;

import java.io.File;
import java.util.*;

public class FilesystemApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        FilesystemApi apiInstance = new FilesystemApi();
        String body = ; // String | 
        try {
            apiInstance.filesystemStatfsPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling FilesystemApi#filesystemStatfsPost");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::FilesystemApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::FilesystemApi->new();
my $body = WWW::SwaggerClient::Object::String->new(); # String | 

eval { 
    $api_instance->filesystemStatfsPost(body => $body);
};
if ($@) {
    warn "Exception when calling FilesystemApi->filesystemStatfsPost: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.FilesystemApi()
body =  # String |  (optional)

try: 
    api_instance.filesystem_statfs_post(body=body)
except ApiException as e:
    print("Exception when calling FilesystemApi->filesystemStatfsPost: %s\n" % e)

Parameters

Body parameters
Name Description
body

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


Ftp

ftpGet


/ftp

Usage and SDK Samples

curl -X GET -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/ftp"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.FtpApi;

import java.io.File;
import java.util.*;

public class FtpApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        FtpApi apiInstance = new FtpApi();
        try {
            apiInstance.ftpGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling FtpApi#ftpGet");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::FtpApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::FtpApi->new();

eval { 
    $api_instance->ftpGet();
};
if ($@) {
    warn "Exception when calling FtpApi->ftpGet: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.FtpApi()

try: 
    api_instance.ftp_get()
except ApiException as e:
    print("Exception when calling FtpApi->ftpGet: %s\n" % e)

Parameters

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


ftpPut

Update ftp service configuration. `clients` is an integer value which sets the maximum number of simultaneous clients allowed. It defaults to 32. `ipconnections` is an integer value which shows the maximum number of connections per IP address. It defaults to 0 which equals to unlimited. `timeout` is the maximum client idle time in seconds before client is disconnected. `rootlogin` is a boolean value which when configured to true enables login as root. This is generally discouraged because of the security risks. `onlyanonymous` allows anonymous FTP logins with access to the directory specified by `anonpath`. `banner` is a message displayed to local login users after they successfully authenticate. It is not displayed to anonymous login users. `filemask` sets the default permissions for newly created files which by default are 077. `dirmask` sets the default permissions for newly created directories which by default are 077. `resume` if set allows FTP clients to resume interrupted transfers. `fxp` if set to true indicates that File eXchange Protocol is enabled. Generally it is discouraged as it makes the server vulnerable to FTP bounce attacks. `defaultroot` when set ensures that for local users, home directory access is only granted if the user is a member of group wheel. `ident` is a boolean value which when set to true indicates that IDENT authentication is required. If identd is not running on the client, this can result in timeouts. `masqaddress` is the public IP address or hostname which is set if FTP clients cannot connect through a NAT device. `localuserbw` is a positive integer value which indicates maximum upload bandwidth in KB/s for local user. Default of zero indicates unlimited upload bandwidth ( from the FTP server configuration ). `localuserdlbw` is a positive integer value which indicates maximum download bandwidth in KB/s for local user. Default of zero indicates unlimited download bandwidth ( from the FTP server configuration ). `anonuserbw` is a positive integer value which indicates maximum upload bandwidth in KB/s for anonymous user. Default of zero indicates unlimited upload bandwidth ( from the FTP server configuration ). `anonuserdlbw` is a positive integer value which indicates maximum download bandwidth in KB/s for anonymous user. Default of zero indicates unlimited download bandwidth ( from the FTP server configuration ). `tls` is a boolean value which when set indicates that encrypted connections are enabled. This requires a certificate to be configured first with the certificate service and the id of certificate is passed on in `ssltls_certificate`. `tls_policy` defines whether the control channel, data channel, both channels, or neither channel of an FTP session must occur over SSL/TLS. `tls_opt_enable_diags` is a boolean value when set, logs verbosely. This is helpful when troubleshooting a connection. `options` is a string used to add proftpd(8) parameters not covered by ftp service.


/ftp

Usage and SDK Samples

curl -X PUT -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/ftp"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.FtpApi;

import java.io.File;
import java.util.*;

public class FtpApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        FtpApi apiInstance = new FtpApi();
        Ftp_update_0 body = ; // Ftp_update_0 | 
        try {
            apiInstance.ftpPut(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling FtpApi#ftpPut");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::FtpApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::FtpApi->new();
my $body = WWW::SwaggerClient::Object::Ftp_update_0->new(); # Ftp_update_0 | 

eval { 
    $api_instance->ftpPut(body => $body);
};
if ($@) {
    warn "Exception when calling FtpApi->ftpPut: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.FtpApi()
body =  # Ftp_update_0 |  (optional)

try: 
    api_instance.ftp_put(body=body)
except ApiException as e:
    print("Exception when calling FtpApi->ftpPut: %s\n" % e)

Parameters

Body parameters
Name Description
body

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


Group

groupGet

Query groups with `query-filters` and `query-options`. As a performance optimization, only local groups will be queried by default. Groups from directory services such as NIS, LDAP, or Active Directory will be included in query results if the option `{'extra': {'search_dscache': True}}` is specified.


/group

Usage and SDK Samples

curl -X GET -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/group?limit=&offset=&count=&sort="
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.GroupApi;

import java.io.File;
import java.util.*;

public class GroupApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        GroupApi apiInstance = new GroupApi();
        Integer limit = 56; // Integer | 
        Integer offset = 56; // Integer | 
        Boolean count = true; // Boolean | 
        String sort = sort_example; // String | 
        try {
            apiInstance.groupGet(limit, offset, count, sort);
        } catch (ApiException e) {
            System.err.println("Exception when calling GroupApi#groupGet");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::GroupApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::GroupApi->new();
my $limit = 56; # Integer | 
my $offset = 56; # Integer | 
my $count = true; # Boolean | 
my $sort = sort_example; # String | 

eval { 
    $api_instance->groupGet(limit => $limit, offset => $offset, count => $count, sort => $sort);
};
if ($@) {
    warn "Exception when calling GroupApi->groupGet: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.GroupApi()
limit = 56 # Integer |  (optional)
offset = 56 # Integer |  (optional)
count = true # Boolean |  (optional)
sort = sort_example # String |  (optional)

try: 
    api_instance.group_get(limit=limit, offset=offset, count=count, sort=sort)
except ApiException as e:
    print("Exception when calling GroupApi->groupGet: %s\n" % e)

Parameters

Query parameters
Name Description
limit
Integer
offset
Integer
count
Boolean
sort
String

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


groupGetGroupObjPost

Returns dictionary containing information from struct grp for the group specified by either the groupname or gid. Bypasses group cache.


/group/get_group_obj

Usage and SDK Samples

curl -X POST -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/group/get_group_obj"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.GroupApi;

import java.io.File;
import java.util.*;

public class GroupApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        GroupApi apiInstance = new GroupApi();
        Group_get_group_obj_0 body = ; // Group_get_group_obj_0 | 
        try {
            apiInstance.groupGetGroupObjPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling GroupApi#groupGetGroupObjPost");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::GroupApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::GroupApi->new();
my $body = WWW::SwaggerClient::Object::Group_get_group_obj_0->new(); # Group_get_group_obj_0 | 

eval { 
    $api_instance->groupGetGroupObjPost(body => $body);
};
if ($@) {
    warn "Exception when calling GroupApi->groupGetGroupObjPost: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.GroupApi()
body =  # Group_get_group_obj_0 |  (optional)

try: 
    api_instance.group_get_group_obj_post(body=body)
except ApiException as e:
    print("Exception when calling GroupApi->groupGetGroupObjPost: %s\n" % e)

Parameters

Body parameters
Name Description
body

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


groupGetNextGidGet

Get the next available/free gid.


/group/get_next_gid

Usage and SDK Samples

curl -X GET -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/group/get_next_gid"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.GroupApi;

import java.io.File;
import java.util.*;

public class GroupApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        GroupApi apiInstance = new GroupApi();
        try {
            apiInstance.groupGetNextGidGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling GroupApi#groupGetNextGidGet");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::GroupApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::GroupApi->new();

eval { 
    $api_instance->groupGetNextGidGet();
};
if ($@) {
    warn "Exception when calling GroupApi->groupGetNextGidGet: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.GroupApi()

try: 
    api_instance.group_get_next_gid_get()
except ApiException as e:
    print("Exception when calling GroupApi->groupGetNextGidGet: %s\n" % e)

Parameters

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


groupIdIdDelete

Delete group `id`. The `delete_users` option deletes all users that have this group as their primary group.


/group/id/{id}

Usage and SDK Samples

curl -X DELETE -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/group/id/{id}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.GroupApi;

import java.io.File;
import java.util.*;

public class GroupApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        GroupApi apiInstance = new GroupApi();
        Integer id = 56; // Integer | 
        Group_delete_1 body = ; // Group_delete_1 | 
        try {
            apiInstance.groupIdIdDelete(id, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling GroupApi#groupIdIdDelete");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::GroupApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::GroupApi->new();
my $id = 56; # Integer | 
my $body = WWW::SwaggerClient::Object::Group_delete_1->new(); # Group_delete_1 | 

eval { 
    $api_instance->groupIdIdDelete(id => $id, body => $body);
};
if ($@) {
    warn "Exception when calling GroupApi->groupIdIdDelete: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.GroupApi()
id = 56 # Integer | 
body =  # Group_delete_1 |  (optional)

try: 
    api_instance.group_id_id_delete(id, body=body)
except ApiException as e:
    print("Exception when calling GroupApi->groupIdIdDelete: %s\n" % e)

Parameters

Path parameters
Name Description
id*
Integer
Required
Body parameters
Name Description
body

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


groupIdIdGet

Query groups with `query-filters` and `query-options`. As a performance optimization, only local groups will be queried by default. Groups from directory services such as NIS, LDAP, or Active Directory will be included in query results if the option `{'extra': {'search_dscache': True}}` is specified.


/group/id/{id}

Usage and SDK Samples

curl -X GET -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/group/id/{id}?limit=&offset=&count=&sort="
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.GroupApi;

import java.io.File;
import java.util.*;

public class GroupApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        GroupApi apiInstance = new GroupApi();
        array[null] id = ; // array[null] | 
        Integer limit = 56; // Integer | 
        Integer offset = 56; // Integer | 
        Boolean count = true; // Boolean | 
        String sort = sort_example; // String | 
        try {
            apiInstance.groupIdIdGet(id, limit, offset, count, sort);
        } catch (ApiException e) {
            System.err.println("Exception when calling GroupApi#groupIdIdGet");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::GroupApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::GroupApi->new();
my $id = []; # array[null] | 
my $limit = 56; # Integer | 
my $offset = 56; # Integer | 
my $count = true; # Boolean | 
my $sort = sort_example; # String | 

eval { 
    $api_instance->groupIdIdGet(id => $id, limit => $limit, offset => $offset, count => $count, sort => $sort);
};
if ($@) {
    warn "Exception when calling GroupApi->groupIdIdGet: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.GroupApi()
id =  # array[null] | 
limit = 56 # Integer |  (optional)
offset = 56 # Integer |  (optional)
count = true # Boolean |  (optional)
sort = sort_example # String |  (optional)

try: 
    api_instance.group_id_id_get(id, limit=limit, offset=offset, count=count, sort=sort)
except ApiException as e:
    print("Exception when calling GroupApi->groupIdIdGet: %s\n" % e)

Parameters

Path parameters
Name Description
id*
array[null]
Required
Query parameters
Name Description
limit
Integer
offset
Integer
count
Boolean
sort
String

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


groupIdIdPut

Update attributes of an existing group.


/group/id/{id}

Usage and SDK Samples

curl -X PUT -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/group/id/{id}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.GroupApi;

import java.io.File;
import java.util.*;

public class GroupApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        GroupApi apiInstance = new GroupApi();
        Integer id = 56; // Integer | 
        Group_update_1 body = ; // Group_update_1 | 
        try {
            apiInstance.groupIdIdPut(id, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling GroupApi#groupIdIdPut");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::GroupApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::GroupApi->new();
my $id = 56; # Integer | 
my $body = WWW::SwaggerClient::Object::Group_update_1->new(); # Group_update_1 | 

eval { 
    $api_instance->groupIdIdPut(id => $id, body => $body);
};
if ($@) {
    warn "Exception when calling GroupApi->groupIdIdPut: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.GroupApi()
id = 56 # Integer | 
body =  # Group_update_1 |  (optional)

try: 
    api_instance.group_id_id_put(id, body=body)
except ApiException as e:
    print("Exception when calling GroupApi->groupIdIdPut: %s\n" % e)

Parameters

Path parameters
Name Description
id*
Integer
Required
Body parameters
Name Description
body

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


groupPost

Create a new group. If `gid` is not provided it is automatically filled with the next one available. `allow_duplicate_gid` allows distinct group names to share the same gid. `users` is a list of user ids (`id` attribute from `user.query`). `smb` specifies whether the group should be mapped into an NT group.


/group

Usage and SDK Samples

curl -X POST -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/group"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.GroupApi;

import java.io.File;
import java.util.*;

public class GroupApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        GroupApi apiInstance = new GroupApi();
        Group_create_0 body = ; // Group_create_0 | 
        try {
            apiInstance.groupPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling GroupApi#groupPost");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::GroupApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::GroupApi->new();
my $body = WWW::SwaggerClient::Object::Group_create_0->new(); # Group_create_0 | 

eval { 
    $api_instance->groupPost(body => $body);
};
if ($@) {
    warn "Exception when calling GroupApi->groupPost: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.GroupApi()
body =  # Group_create_0 |  (optional)

try: 
    api_instance.group_post(body=body)
except ApiException as e:
    print("Exception when calling GroupApi->groupPost: %s\n" % e)

Parameters

Body parameters
Name Description
body

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


Idmap

idmapBackendChoicesGet

Returns array of valid idmap backend choices per directory service.


/idmap/backend_choices

Usage and SDK Samples

curl -X GET -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/idmap/backend_choices"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.IdmapApi;

import java.io.File;
import java.util.*;

public class IdmapApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        IdmapApi apiInstance = new IdmapApi();
        try {
            apiInstance.idmapBackendChoicesGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling IdmapApi#idmapBackendChoicesGet");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::IdmapApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::IdmapApi->new();

eval { 
    $api_instance->idmapBackendChoicesGet();
};
if ($@) {
    warn "Exception when calling IdmapApi->idmapBackendChoicesGet: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.IdmapApi()

try: 
    api_instance.idmap_backend_choices_get()
except ApiException as e:
    print("Exception when calling IdmapApi->idmapBackendChoicesGet: %s\n" % e)

Parameters

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


idmapBackendOptionsGet

This returns full information about idmap backend options. Not all `options` are valid for every backend.


/idmap/backend_options

Usage and SDK Samples

curl -X GET -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/idmap/backend_options"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.IdmapApi;

import java.io.File;
import java.util.*;

public class IdmapApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        IdmapApi apiInstance = new IdmapApi();
        try {
            apiInstance.idmapBackendOptionsGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling IdmapApi#idmapBackendOptionsGet");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::IdmapApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::IdmapApi->new();

eval { 
    $api_instance->idmapBackendOptionsGet();
};
if ($@) {
    warn "Exception when calling IdmapApi->idmapBackendOptionsGet: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.IdmapApi()

try: 
    api_instance.idmap_backend_options_get()
except ApiException as e:
    print("Exception when calling IdmapApi->idmapBackendOptionsGet: %s\n" % e)

Parameters

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


idmapClearIdmapCacheGet

Stop samba, remove the winbindd_cache.tdb file, start samba, flush samba's cache. This should be performed after finalizing idmap changes.


/idmap/clear_idmap_cache

Usage and SDK Samples

curl -X GET -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/idmap/clear_idmap_cache"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.IdmapApi;

import java.io.File;
import java.util.*;

public class IdmapApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        IdmapApi apiInstance = new IdmapApi();
        try {
            apiInstance.idmapClearIdmapCacheGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling IdmapApi#idmapClearIdmapCacheGet");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::IdmapApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::IdmapApi->new();

eval { 
    $api_instance->idmapClearIdmapCacheGet();
};
if ($@) {
    warn "Exception when calling IdmapApi->idmapClearIdmapCacheGet: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.IdmapApi()

try: 
    api_instance.idmap_clear_idmap_cache_get()
except ApiException as e:
    print("Exception when calling IdmapApi->idmapClearIdmapCacheGet: %s\n" % e)

Parameters

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


idmapGet


/idmap

Usage and SDK Samples

curl -X GET -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/idmap?limit=&offset=&count=&sort="
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.IdmapApi;

import java.io.File;
import java.util.*;

public class IdmapApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        IdmapApi apiInstance = new IdmapApi();
        Integer limit = 56; // Integer | 
        Integer offset = 56; // Integer | 
        Boolean count = true; // Boolean | 
        String sort = sort_example; // String | 
        try {
            apiInstance.idmapGet(limit, offset, count, sort);
        } catch (ApiException e) {
            System.err.println("Exception when calling IdmapApi#idmapGet");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::IdmapApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::IdmapApi->new();
my $limit = 56; # Integer | 
my $offset = 56; # Integer | 
my $count = true; # Boolean | 
my $sort = sort_example; # String | 

eval { 
    $api_instance->idmapGet(limit => $limit, offset => $offset, count => $count, sort => $sort);
};
if ($@) {
    warn "Exception when calling IdmapApi->idmapGet: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.IdmapApi()
limit = 56 # Integer |  (optional)
offset = 56 # Integer |  (optional)
count = true # Boolean |  (optional)
sort = sort_example # String |  (optional)

try: 
    api_instance.idmap_get(limit=limit, offset=offset, count=count, sort=sort)
except ApiException as e:
    print("Exception when calling IdmapApi->idmapGet: %s\n" % e)

Parameters

Query parameters
Name Description
limit
Integer
offset
Integer
count
Boolean
sort
String

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


idmapIdIdDelete

Delete a domain by id. Deletion of default system domains is not permitted.


/idmap/id/{id}

Usage and SDK Samples

curl -X DELETE -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/idmap/id/{id}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.IdmapApi;

import java.io.File;
import java.util.*;

public class IdmapApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        IdmapApi apiInstance = new IdmapApi();
        Integer id = 56; // Integer | 
        try {
            apiInstance.idmapIdIdDelete(id);
        } catch (ApiException e) {
            System.err.println("Exception when calling IdmapApi#idmapIdIdDelete");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::IdmapApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::IdmapApi->new();
my $id = 56; # Integer | 

eval { 
    $api_instance->idmapIdIdDelete(id => $id);
};
if ($@) {
    warn "Exception when calling IdmapApi->idmapIdIdDelete: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.IdmapApi()
id = 56 # Integer | 

try: 
    api_instance.idmap_id_id_delete(id)
except ApiException as e:
    print("Exception when calling IdmapApi->idmapIdIdDelete: %s\n" % e)

Parameters

Path parameters
Name Description
id*
Integer
Required

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


idmapIdIdGet


/idmap/id/{id}

Usage and SDK Samples

curl -X GET -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/idmap/id/{id}?limit=&offset=&count=&sort="
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.IdmapApi;

import java.io.File;
import java.util.*;

public class IdmapApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        IdmapApi apiInstance = new IdmapApi();
        array[null] id = ; // array[null] | 
        Integer limit = 56; // Integer | 
        Integer offset = 56; // Integer | 
        Boolean count = true; // Boolean | 
        String sort = sort_example; // String | 
        try {
            apiInstance.idmapIdIdGet(id, limit, offset, count, sort);
        } catch (ApiException e) {
            System.err.println("Exception when calling IdmapApi#idmapIdIdGet");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::IdmapApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::IdmapApi->new();
my $id = []; # array[null] | 
my $limit = 56; # Integer | 
my $offset = 56; # Integer | 
my $count = true; # Boolean | 
my $sort = sort_example; # String | 

eval { 
    $api_instance->idmapIdIdGet(id => $id, limit => $limit, offset => $offset, count => $count, sort => $sort);
};
if ($@) {
    warn "Exception when calling IdmapApi->idmapIdIdGet: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.IdmapApi()
id =  # array[null] | 
limit = 56 # Integer |  (optional)
offset = 56 # Integer |  (optional)
count = true # Boolean |  (optional)
sort = sort_example # String |  (optional)

try: 
    api_instance.idmap_id_id_get(id, limit=limit, offset=offset, count=count, sort=sort)
except ApiException as e:
    print("Exception when calling IdmapApi->idmapIdIdGet: %s\n" % e)

Parameters

Path parameters
Name Description
id*
array[null]
Required
Query parameters
Name Description
limit
Integer
offset
Integer
count
Boolean
sort
String

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


idmapIdIdPut

Update a domain by id.


/idmap/id/{id}

Usage and SDK Samples

curl -X PUT -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/idmap/id/{id}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.IdmapApi;

import java.io.File;
import java.util.*;

public class IdmapApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        IdmapApi apiInstance = new IdmapApi();
        Integer id = 56; // Integer | 
        Idmap_update_1 body = ; // Idmap_update_1 | 
        try {
            apiInstance.idmapIdIdPut(id, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling IdmapApi#idmapIdIdPut");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::IdmapApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::IdmapApi->new();
my $id = 56; # Integer | 
my $body = WWW::SwaggerClient::Object::Idmap_update_1->new(); # Idmap_update_1 | 

eval { 
    $api_instance->idmapIdIdPut(id => $id, body => $body);
};
if ($@) {
    warn "Exception when calling IdmapApi->idmapIdIdPut: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.IdmapApi()
id = 56 # Integer | 
body =  # Idmap_update_1 |  (optional)

try: 
    api_instance.idmap_id_id_put(id, body=body)
except ApiException as e:
    print("Exception when calling IdmapApi->idmapIdIdPut: %s\n" % e)

Parameters

Path parameters
Name Description
id*
Integer
Required
Body parameters
Name Description
body

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


idmapOptionsChoicesPost

Returns a list of supported keys for the specified idmap backend.


/idmap/options_choices

Usage and SDK Samples

curl -X POST -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/idmap/options_choices"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.IdmapApi;

import java.io.File;
import java.util.*;

public class IdmapApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        IdmapApi apiInstance = new IdmapApi();
        String body = ; // String | 
        try {
            apiInstance.idmapOptionsChoicesPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling IdmapApi#idmapOptionsChoicesPost");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::IdmapApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::IdmapApi->new();
my $body = WWW::SwaggerClient::Object::String->new(); # String | 

eval { 
    $api_instance->idmapOptionsChoicesPost(body => $body);
};
if ($@) {
    warn "Exception when calling IdmapApi->idmapOptionsChoicesPost: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.IdmapApi()
body =  # String |  (optional)

try: 
    api_instance.idmap_options_choices_post(body=body)
except ApiException as e:
    print("Exception when calling IdmapApi->idmapOptionsChoicesPost: %s\n" % e)

Parameters

Body parameters
Name Description
body

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


idmapPost

Create a new IDMAP domain. These domains must be unique. This table will be automatically populated after joining an Active Directory domain if "allow trusted domains" is set to True in the AD service configuration. There are three default system domains: DS_TYPE_ACTIVEDIRECTORY, DS_TYPE_LDAP, DS_TYPE_DEFAULT_DOMAIN. The system domains correspond with the idmap settings under Active Directory, LDAP, and SMB respectively. `name` the pre-windows 2000 domain name. `DNS_domain_name` DNS name of the domain. `idmap_backend` provides a plugin interface for Winbind to use varying backends to store SID/uid/gid mapping tables. The correct setting depends on the environment in which the NAS is deployed. `range_low` and `range_high` specify the UID and GID range for which this backend is authoritative. `certificate_id` references the certificate ID of the SSL certificate to use for certificate-based authentication to a remote LDAP server. This parameter is not supported for all idmap backends as some backends will generate SID to ID mappings algorithmically without causing network traffic. `options` are additional parameters that are backend-dependent: `AD` idmap backend options: `unix_primary_group` If True, the primary group membership is fetched from the LDAP attributes (gidNumber). If False, the primary group membership is calculated via the "primaryGroupID" LDAP attribute. `unix_nss_info` if True winbind will retrieve the login shell and home directory from the LDAP attributes. If False or if the AD LDAP entry lacks the SFU attributes the smb4.conf parameters `template shell` and `template homedir` are used. `schema_mode` Defines the schema that idmap_ad should use when querying Active Directory regarding user and group information. This can be either the RFC2307 schema support included in Windows 2003 R2 or the Service for Unix (SFU) schema. For SFU 3.0 or 3.5 please choose "SFU", for SFU 2.0 please choose "SFU20". The behavior of primary group membership is controlled by the unix_primary_group option. `AUTORID` idmap backend options: `readonly` sets the module to read-only mode. No new ranges will be allocated and new mappings will not be created in the idmap pool. `ignore_builtin` ignores mapping requests for the BUILTIN domain. `LDAP` idmap backend options: `ldap_base_dn` defines the directory base suffix to use for SID/uid/gid mapping entries. `ldap_user_dn` defines the user DN to be used for authentication. `ldap_url` specifies the LDAP server to use for SID/uid/gid map entries. `ssl` specifies whether to encrypt the LDAP transport for the idmap backend. `NSS` idmap backend options: `linked_service` specifies the auxiliary directory service ID provider. `RFC2307` idmap backend options: `domain` specifies the domain for which the idmap backend is being created. Numeric id, short-form domain name, or long-form DNS domain name of the domain may be specified. Entry must be entered as it appears in `idmap.domain`. `range_low` and `range_high` specify the UID and GID range for which this backend is authoritative. `ldap_server` defines the type of LDAP server to use. This can either be an LDAP server provided by the Active Directory Domain (ad) or a stand-alone LDAP server. `bind_path_user` specfies the search base where user objects can be found in the LDAP server. `bind_path_group` specifies the search base where group objects can be found in the LDAP server. `user_cn` query cn attribute instead of uid attribute for the user name in LDAP. `realm` append @realm to cn for groups (and users if user_cn is set) in LDAP queries. `ldmap_domain` when using the LDAP server in the Active Directory server, this allows one to specify the domain where to access the Active Directory server. This allows using trust relationships while keeping all RFC 2307 records in one place. This parameter is optional, the default is to access the AD server in the current domain to query LDAP records. `ldap_url` when using a stand-alone LDAP server, this parameter specifies the LDAP URL for accessing the LDAP server. `ldap_user_dn` defines the user DN to be used for authentication. `ldap_user_dn_password` is the password to be used for LDAP authentication. `realm` defines the realm to use in the user and group names. This is only required when using cn_realm together with a stand-alone ldap server. `RID` backend options: `sssd_compat` generate idmap low range based on same algorithm that SSSD uses by default.


/idmap

Usage and SDK Samples

curl -X POST -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/idmap"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.IdmapApi;

import java.io.File;
import java.util.*;

public class IdmapApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        IdmapApi apiInstance = new IdmapApi();
        Idmap_create_0 body = ; // Idmap_create_0 | 
        try {
            apiInstance.idmapPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling IdmapApi#idmapPost");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::IdmapApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::IdmapApi->new();
my $body = WWW::SwaggerClient::Object::Idmap_create_0->new(); # Idmap_create_0 | 

eval { 
    $api_instance->idmapPost(body => $body);
};
if ($@) {
    warn "Exception when calling IdmapApi->idmapPost: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.IdmapApi()
body =  # Idmap_create_0 |  (optional)

try: 
    api_instance.idmap_post(body=body)
except ApiException as e:
    print("Exception when calling IdmapApi->idmapPost: %s\n" % e)

Parameters

Body parameters
Name Description
body

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


Initshutdownscript

initshutdownscriptGet


/initshutdownscript

Usage and SDK Samples

curl -X GET -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/initshutdownscript?limit=&offset=&count=&sort="
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.InitshutdownscriptApi;

import java.io.File;
import java.util.*;

public class InitshutdownscriptApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        InitshutdownscriptApi apiInstance = new InitshutdownscriptApi();
        Integer limit = 56; // Integer | 
        Integer offset = 56; // Integer | 
        Boolean count = true; // Boolean | 
        String sort = sort_example; // String | 
        try {
            apiInstance.initshutdownscriptGet(limit, offset, count, sort);
        } catch (ApiException e) {
            System.err.println("Exception when calling InitshutdownscriptApi#initshutdownscriptGet");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::InitshutdownscriptApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::InitshutdownscriptApi->new();
my $limit = 56; # Integer | 
my $offset = 56; # Integer | 
my $count = true; # Boolean | 
my $sort = sort_example; # String | 

eval { 
    $api_instance->initshutdownscriptGet(limit => $limit, offset => $offset, count => $count, sort => $sort);
};
if ($@) {
    warn "Exception when calling InitshutdownscriptApi->initshutdownscriptGet: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.InitshutdownscriptApi()
limit = 56 # Integer |  (optional)
offset = 56 # Integer |  (optional)
count = true # Boolean |  (optional)
sort = sort_example # String |  (optional)

try: 
    api_instance.initshutdownscript_get(limit=limit, offset=offset, count=count, sort=sort)
except ApiException as e:
    print("Exception when calling InitshutdownscriptApi->initshutdownscriptGet: %s\n" % e)

Parameters

Query parameters
Name Description
limit
Integer
offset
Integer
count
Boolean
sort
String

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


initshutdownscriptIdIdDelete

Delete init/shutdown task of `id`.


/initshutdownscript/id/{id}

Usage and SDK Samples

curl -X DELETE -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/initshutdownscript/id/{id}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.InitshutdownscriptApi;

import java.io.File;
import java.util.*;

public class InitshutdownscriptApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        InitshutdownscriptApi apiInstance = new InitshutdownscriptApi();
        Integer id = 56; // Integer | 
        try {
            apiInstance.initshutdownscriptIdIdDelete(id);
        } catch (ApiException e) {
            System.err.println("Exception when calling InitshutdownscriptApi#initshutdownscriptIdIdDelete");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::InitshutdownscriptApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::InitshutdownscriptApi->new();
my $id = 56; # Integer | 

eval { 
    $api_instance->initshutdownscriptIdIdDelete(id => $id);
};
if ($@) {
    warn "Exception when calling InitshutdownscriptApi->initshutdownscriptIdIdDelete: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.InitshutdownscriptApi()
id = 56 # Integer | 

try: 
    api_instance.initshutdownscript_id_id_delete(id)
except ApiException as e:
    print("Exception when calling InitshutdownscriptApi->initshutdownscriptIdIdDelete: %s\n" % e)

Parameters

Path parameters
Name Description
id*
Integer
Required

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


initshutdownscriptIdIdGet


/initshutdownscript/id/{id}

Usage and SDK Samples

curl -X GET -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/initshutdownscript/id/{id}?limit=&offset=&count=&sort="
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.InitshutdownscriptApi;

import java.io.File;
import java.util.*;

public class InitshutdownscriptApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        InitshutdownscriptApi apiInstance = new InitshutdownscriptApi();
        array[null] id = ; // array[null] | 
        Integer limit = 56; // Integer | 
        Integer offset = 56; // Integer | 
        Boolean count = true; // Boolean | 
        String sort = sort_example; // String | 
        try {
            apiInstance.initshutdownscriptIdIdGet(id, limit, offset, count, sort);
        } catch (ApiException e) {
            System.err.println("Exception when calling InitshutdownscriptApi#initshutdownscriptIdIdGet");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::InitshutdownscriptApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::InitshutdownscriptApi->new();
my $id = []; # array[null] | 
my $limit = 56; # Integer | 
my $offset = 56; # Integer | 
my $count = true; # Boolean | 
my $sort = sort_example; # String | 

eval { 
    $api_instance->initshutdownscriptIdIdGet(id => $id, limit => $limit, offset => $offset, count => $count, sort => $sort);
};
if ($@) {
    warn "Exception when calling InitshutdownscriptApi->initshutdownscriptIdIdGet: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.InitshutdownscriptApi()
id =  # array[null] | 
limit = 56 # Integer |  (optional)
offset = 56 # Integer |  (optional)
count = true # Boolean |  (optional)
sort = sort_example # String |  (optional)

try: 
    api_instance.initshutdownscript_id_id_get(id, limit=limit, offset=offset, count=count, sort=sort)
except ApiException as e:
    print("Exception when calling InitshutdownscriptApi->initshutdownscriptIdIdGet: %s\n" % e)

Parameters

Path parameters
Name Description
id*
array[null]
Required
Query parameters
Name Description
limit
Integer
offset
Integer
count
Boolean
sort
String

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


initshutdownscriptIdIdPut

Update initshutdown script task of `id`.


/initshutdownscript/id/{id}

Usage and SDK Samples

curl -X PUT -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/initshutdownscript/id/{id}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.InitshutdownscriptApi;

import java.io.File;
import java.util.*;

public class InitshutdownscriptApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        InitshutdownscriptApi apiInstance = new InitshutdownscriptApi();
        Integer id = 56; // Integer | 
        Initshutdownscript_update_1 body = ; // Initshutdownscript_update_1 | 
        try {
            apiInstance.initshutdownscriptIdIdPut(id, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling InitshutdownscriptApi#initshutdownscriptIdIdPut");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::InitshutdownscriptApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::InitshutdownscriptApi->new();
my $id = 56; # Integer | 
my $body = WWW::SwaggerClient::Object::Initshutdownscript_update_1->new(); # Initshutdownscript_update_1 | 

eval { 
    $api_instance->initshutdownscriptIdIdPut(id => $id, body => $body);
};
if ($@) {
    warn "Exception when calling InitshutdownscriptApi->initshutdownscriptIdIdPut: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.InitshutdownscriptApi()
id = 56 # Integer | 
body =  # Initshutdownscript_update_1 |  (optional)

try: 
    api_instance.initshutdownscript_id_id_put(id, body=body)
except ApiException as e:
    print("Exception when calling InitshutdownscriptApi->initshutdownscriptIdIdPut: %s\n" % e)

Parameters

Path parameters
Name Description
id*
Integer
Required
Body parameters
Name Description
body

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


initshutdownscriptPost

Create an initshutdown script task. `type` indicates if a command or script should be executed at `when`. There are three choices for `when`: 1) PREINIT - This is early in the boot process before all the services / rc scripts have started 2) POSTINIT - This is late in the boot process when most of the services / rc scripts have started 3) SHUTDOWN - This is on shutdown `timeout` is an integer value which indicates time in seconds which the system should wait for the execution of script/command. It should be noted that a hard limit for a timeout is configured by the base OS, so when a script/command is set to execute on SHUTDOWN, the hard limit configured by the base OS is changed adding the timeout specified by script/command so it can be ensured that it executes as desired and is not interrupted by the base OS's limit.


/initshutdownscript

Usage and SDK Samples

curl -X POST -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/initshutdownscript"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.InitshutdownscriptApi;

import java.io.File;
import java.util.*;

public class InitshutdownscriptApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        InitshutdownscriptApi apiInstance = new InitshutdownscriptApi();
        Initshutdownscript_create_0 body = ; // Initshutdownscript_create_0 | 
        try {
            apiInstance.initshutdownscriptPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling InitshutdownscriptApi#initshutdownscriptPost");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::InitshutdownscriptApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::InitshutdownscriptApi->new();
my $body = WWW::SwaggerClient::Object::Initshutdownscript_create_0->new(); # Initshutdownscript_create_0 | 

eval { 
    $api_instance->initshutdownscriptPost(body => $body);
};
if ($@) {
    warn "Exception when calling InitshutdownscriptApi->initshutdownscriptPost: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.InitshutdownscriptApi()
body =  # Initshutdownscript_create_0 |  (optional)

try: 
    api_instance.initshutdownscript_post(body=body)
except ApiException as e:
    print("Exception when calling InitshutdownscriptApi->initshutdownscriptPost: %s\n" % e)

Parameters

Body parameters
Name Description
body

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


Interface

interfaceBridgeMembersChoicesPost

Return available interface choices for `bridge_members` attribute. `id` is the name of the bridge interface to update or null for a new bridge interface.


/interface/bridge_members_choices

Usage and SDK Samples

curl -X POST -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/interface/bridge_members_choices"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.InterfaceApi;

import java.io.File;
import java.util.*;

public class InterfaceApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        InterfaceApi apiInstance = new InterfaceApi();
        String body = ; // String | 
        try {
            apiInstance.interfaceBridgeMembersChoicesPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling InterfaceApi#interfaceBridgeMembersChoicesPost");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::InterfaceApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::InterfaceApi->new();
my $body = WWW::SwaggerClient::Object::String->new(); # String | 

eval { 
    $api_instance->interfaceBridgeMembersChoicesPost(body => $body);
};
if ($@) {
    warn "Exception when calling InterfaceApi->interfaceBridgeMembersChoicesPost: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.InterfaceApi()
body =  # String |  (optional)

try: 
    api_instance.interface_bridge_members_choices_post(body=body)
except ApiException as e:
    print("Exception when calling InterfaceApi->interfaceBridgeMembersChoicesPost: %s\n" % e)

Parameters

Body parameters
Name Description
body

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


interfaceCheckinGet

After interfaces changes are committed with checkin timeout this method needs to be called within that timeout limit to prevent reverting the changes. This is to ensure user verifies the changes went as planned and its working.


/interface/checkin

Usage and SDK Samples

curl -X GET -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/interface/checkin"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.InterfaceApi;

import java.io.File;
import java.util.*;

public class InterfaceApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        InterfaceApi apiInstance = new InterfaceApi();
        try {
            apiInstance.interfaceCheckinGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling InterfaceApi#interfaceCheckinGet");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::InterfaceApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::InterfaceApi->new();

eval { 
    $api_instance->interfaceCheckinGet();
};
if ($@) {
    warn "Exception when calling InterfaceApi->interfaceCheckinGet: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.InterfaceApi()

try: 
    api_instance.interface_checkin_get()
except ApiException as e:
    print("Exception when calling InterfaceApi->interfaceCheckinGet: %s\n" % e)

Parameters

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


interfaceCheckinWaitingGet

Returns wether or not we are waiting user to checkin the applied network changes before they are rolled back. Value is in number of seconds or null.


/interface/checkin_waiting

Usage and SDK Samples

curl -X GET -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/interface/checkin_waiting"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.InterfaceApi;

import java.io.File;
import java.util.*;

public class InterfaceApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        InterfaceApi apiInstance = new InterfaceApi();
        try {
            apiInstance.interfaceCheckinWaitingGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling InterfaceApi#interfaceCheckinWaitingGet");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::InterfaceApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::InterfaceApi->new();

eval { 
    $api_instance->interfaceCheckinWaitingGet();
};
if ($@) {
    warn "Exception when calling InterfaceApi->interfaceCheckinWaitingGet: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.InterfaceApi()

try: 
    api_instance.interface_checkin_waiting_get()
except ApiException as e:
    print("Exception when calling InterfaceApi->interfaceCheckinWaitingGet: %s\n" % e)

Parameters

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


interfaceChoicesPost

Choices of available network interfaces. `bridge_members` will include BRIDGE members. `lag_ports` will include LINK_AGGREGATION ports. `vlan_parent` will include VLAN parent interface. `exclude` is a list of interfaces prefix to remove. `include` is a list of interfaces that should not be removed.


/interface/choices

Usage and SDK Samples

curl -X POST -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/interface/choices"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.InterfaceApi;

import java.io.File;
import java.util.*;

public class InterfaceApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        InterfaceApi apiInstance = new InterfaceApi();
        Interface_choices_0 body = ; // Interface_choices_0 | 
        try {
            apiInstance.interfaceChoicesPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling InterfaceApi#interfaceChoicesPost");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::InterfaceApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::InterfaceApi->new();
my $body = WWW::SwaggerClient::Object::Interface_choices_0->new(); # Interface_choices_0 | 

eval { 
    $api_instance->interfaceChoicesPost(body => $body);
};
if ($@) {
    warn "Exception when calling InterfaceApi->interfaceChoicesPost: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.InterfaceApi()
body =  # Interface_choices_0 |  (optional)

try: 
    api_instance.interface_choices_post(body=body)
except ApiException as e:
    print("Exception when calling InterfaceApi->interfaceChoicesPost: %s\n" % e)

Parameters

Body parameters
Name Description
body

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


interfaceCommitPost

Commit/apply pending interfaces changes. `rollback` as true (default) will rollback changes in case they fail to apply. `checkin_timeout` is the time in seconds it will wait for the checkin call to acknowledge the interfaces changes happened as planned from the user. If checkin does not happen within this period of time the changes will get reverted.


/interface/commit

Usage and SDK Samples

curl -X POST -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/interface/commit"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.InterfaceApi;

import java.io.File;
import java.util.*;

public class InterfaceApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        InterfaceApi apiInstance = new InterfaceApi();
        Interface_commit_0 body = ; // Interface_commit_0 | 
        try {
            apiInstance.interfaceCommitPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling InterfaceApi#interfaceCommitPost");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::InterfaceApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::InterfaceApi->new();
my $body = WWW::SwaggerClient::Object::Interface_commit_0->new(); # Interface_commit_0 | 

eval { 
    $api_instance->interfaceCommitPost(body => $body);
};
if ($@) {
    warn "Exception when calling InterfaceApi->interfaceCommitPost: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.InterfaceApi()
body =  # Interface_commit_0 |  (optional)

try: 
    api_instance.interface_commit_post(body=body)
except ApiException as e:
    print("Exception when calling InterfaceApi->interfaceCommitPost: %s\n" % e)

Parameters

Body parameters
Name Description
body

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


interfaceGet

Query Interfaces with `query-filters` and `query-options`


/interface

Usage and SDK Samples

curl -X GET -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/interface?limit=&offset=&count=&sort="
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.InterfaceApi;

import java.io.File;
import java.util.*;

public class InterfaceApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        InterfaceApi apiInstance = new InterfaceApi();
        Integer limit = 56; // Integer | 
        Integer offset = 56; // Integer | 
        Boolean count = true; // Boolean | 
        String sort = sort_example; // String | 
        try {
            apiInstance.interfaceGet(limit, offset, count, sort);
        } catch (ApiException e) {
            System.err.println("Exception when calling InterfaceApi#interfaceGet");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::InterfaceApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::InterfaceApi->new();
my $limit = 56; # Integer | 
my $offset = 56; # Integer | 
my $count = true; # Boolean | 
my $sort = sort_example; # String | 

eval { 
    $api_instance->interfaceGet(limit => $limit, offset => $offset, count => $count, sort => $sort);
};
if ($@) {
    warn "Exception when calling InterfaceApi->interfaceGet: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.InterfaceApi()
limit = 56 # Integer |  (optional)
offset = 56 # Integer |  (optional)
count = true # Boolean |  (optional)
sort = sort_example # String |  (optional)

try: 
    api_instance.interface_get(limit=limit, offset=offset, count=count, sort=sort)
except ApiException as e:
    print("Exception when calling InterfaceApi->interfaceGet: %s\n" % e)

Parameters

Query parameters
Name Description
limit
Integer
offset
Integer
count
Boolean
sort
String

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


interfaceHasPendingChangesGet

Returns whether there are pending interfaces changes to be applied or not.


/interface/has_pending_changes

Usage and SDK Samples

curl -X GET -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/interface/has_pending_changes"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.InterfaceApi;

import java.io.File;
import java.util.*;

public class InterfaceApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        InterfaceApi apiInstance = new InterfaceApi();
        try {
            apiInstance.interfaceHasPendingChangesGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling InterfaceApi#interfaceHasPendingChangesGet");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::InterfaceApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::InterfaceApi->new();

eval { 
    $api_instance->interfaceHasPendingChangesGet();
};
if ($@) {
    warn "Exception when calling InterfaceApi->interfaceHasPendingChangesGet: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.InterfaceApi()

try: 
    api_instance.interface_has_pending_changes_get()
except ApiException as e:
    print("Exception when calling InterfaceApi->interfaceHasPendingChangesGet: %s\n" % e)

Parameters

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


interfaceIdIdDelete

Delete Interface of `id`.


/interface/id/{id}

Usage and SDK Samples

curl -X DELETE -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/interface/id/{id}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.InterfaceApi;

import java.io.File;
import java.util.*;

public class InterfaceApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        InterfaceApi apiInstance = new InterfaceApi();
        String id = id_example; // String | 
        try {
            apiInstance.interfaceIdIdDelete(id);
        } catch (ApiException e) {
            System.err.println("Exception when calling InterfaceApi#interfaceIdIdDelete");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::InterfaceApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::InterfaceApi->new();
my $id = id_example; # String | 

eval { 
    $api_instance->interfaceIdIdDelete(id => $id);
};
if ($@) {
    warn "Exception when calling InterfaceApi->interfaceIdIdDelete: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.InterfaceApi()
id = id_example # String | 

try: 
    api_instance.interface_id_id_delete(id)
except ApiException as e:
    print("Exception when calling InterfaceApi->interfaceIdIdDelete: %s\n" % e)

Parameters

Path parameters
Name Description
id*
String
Required

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


interfaceIdIdGet

Query Interfaces with `query-filters` and `query-options`


/interface/id/{id}

Usage and SDK Samples

curl -X GET -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/interface/id/{id}?limit=&offset=&count=&sort="
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.InterfaceApi;

import java.io.File;
import java.util.*;

public class InterfaceApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        InterfaceApi apiInstance = new InterfaceApi();
        array[null] id = ; // array[null] | 
        Integer limit = 56; // Integer | 
        Integer offset = 56; // Integer | 
        Boolean count = true; // Boolean | 
        String sort = sort_example; // String | 
        try {
            apiInstance.interfaceIdIdGet(id, limit, offset, count, sort);
        } catch (ApiException e) {
            System.err.println("Exception when calling InterfaceApi#interfaceIdIdGet");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::InterfaceApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::InterfaceApi->new();
my $id = []; # array[null] | 
my $limit = 56; # Integer | 
my $offset = 56; # Integer | 
my $count = true; # Boolean | 
my $sort = sort_example; # String | 

eval { 
    $api_instance->interfaceIdIdGet(id => $id, limit => $limit, offset => $offset, count => $count, sort => $sort);
};
if ($@) {
    warn "Exception when calling InterfaceApi->interfaceIdIdGet: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.InterfaceApi()
id =  # array[null] | 
limit = 56 # Integer |  (optional)
offset = 56 # Integer |  (optional)
count = true # Boolean |  (optional)
sort = sort_example # String |  (optional)

try: 
    api_instance.interface_id_id_get(id, limit=limit, offset=offset, count=count, sort=sort)
except ApiException as e:
    print("Exception when calling InterfaceApi->interfaceIdIdGet: %s\n" % e)

Parameters

Path parameters
Name Description
id*
array[null]
Required
Query parameters
Name Description
limit
Integer
offset
Integer
count
Boolean
sort
String

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


interfaceIdIdPut

Update Interface of `id`.


/interface/id/{id}

Usage and SDK Samples

curl -X PUT -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/interface/id/{id}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.InterfaceApi;

import java.io.File;
import java.util.*;

public class InterfaceApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        InterfaceApi apiInstance = new InterfaceApi();
        String id = id_example; // String | 
        Interface_update_1 body = ; // Interface_update_1 | 
        try {
            apiInstance.interfaceIdIdPut(id, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling InterfaceApi#interfaceIdIdPut");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::InterfaceApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::InterfaceApi->new();
my $id = id_example; # String | 
my $body = WWW::SwaggerClient::Object::Interface_update_1->new(); # Interface_update_1 | 

eval { 
    $api_instance->interfaceIdIdPut(id => $id, body => $body);
};
if ($@) {
    warn "Exception when calling InterfaceApi->interfaceIdIdPut: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.InterfaceApi()
id = id_example # String | 
body =  # Interface_update_1 |  (optional)

try: 
    api_instance.interface_id_id_put(id, body=body)
except ApiException as e:
    print("Exception when calling InterfaceApi->interfaceIdIdPut: %s\n" % e)

Parameters

Path parameters
Name Description
id*
String
Required
Body parameters
Name Description
body

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


interfaceIpInUsePost

Get all IPv4 / Ipv6 from all valid interfaces, excluding tap and epair. `loopback` will return loopback interface addresses. `any` will return wildcard addresses (0.0.0.0 and ::). `static` when enabled will ensure we only return static ip's configured. Returns a list of dicts - eg - [ { "type": "INET6", "address": "fe80::5054:ff:fe16:4aac", "netmask": 64 }, { "type": "INET", "address": "192.168.122.148", "netmask": 24, "broadcast": "192.168.122.255" }, ]


/interface/ip_in_use

Usage and SDK Samples

curl -X POST -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/interface/ip_in_use"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.InterfaceApi;

import java.io.File;
import java.util.*;

public class InterfaceApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        InterfaceApi apiInstance = new InterfaceApi();
        Interface_ip_in_use_0 body = ; // Interface_ip_in_use_0 | 
        try {
            apiInstance.interfaceIpInUsePost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling InterfaceApi#interfaceIpInUsePost");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::InterfaceApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::InterfaceApi->new();
my $body = WWW::SwaggerClient::Object::Interface_ip_in_use_0->new(); # Interface_ip_in_use_0 | 

eval { 
    $api_instance->interfaceIpInUsePost(body => $body);
};
if ($@) {
    warn "Exception when calling InterfaceApi->interfaceIpInUsePost: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.InterfaceApi()
body =  # Interface_ip_in_use_0 |  (optional)

try: 
    api_instance.interface_ip_in_use_post(body=body)
except ApiException as e:
    print("Exception when calling InterfaceApi->interfaceIpInUsePost: %s\n" % e)

Parameters

Body parameters
Name Description
body

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


interfaceLagPortsChoicesPost

Return available interface choices for `lag_ports` attribute. `id` is the name of the LAG interface to update or null for a new LAG interface.


/interface/lag_ports_choices

Usage and SDK Samples

curl -X POST -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/interface/lag_ports_choices"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.InterfaceApi;

import java.io.File;
import java.util.*;

public class InterfaceApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        InterfaceApi apiInstance = new InterfaceApi();
        String body = ; // String | 
        try {
            apiInstance.interfaceLagPortsChoicesPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling InterfaceApi#interfaceLagPortsChoicesPost");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::InterfaceApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::InterfaceApi->new();
my $body = WWW::SwaggerClient::Object::String->new(); # String | 

eval { 
    $api_instance->interfaceLagPortsChoicesPost(body => $body);
};
if ($@) {
    warn "Exception when calling InterfaceApi->interfaceLagPortsChoicesPost: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.InterfaceApi()
body =  # String |  (optional)

try: 
    api_instance.interface_lag_ports_choices_post(body=body)
except ApiException as e:
    print("Exception when calling InterfaceApi->interfaceLagPortsChoicesPost: %s\n" % e)

Parameters

Body parameters
Name Description
body

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


interfaceLagSetupGet


/interface/lag_setup

Usage and SDK Samples

curl -X GET -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/interface/lag_setup"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.InterfaceApi;

import java.io.File;
import java.util.*;

public class InterfaceApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        InterfaceApi apiInstance = new InterfaceApi();
        try {
            apiInstance.interfaceLagSetupGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling InterfaceApi#interfaceLagSetupGet");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::InterfaceApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::InterfaceApi->new();

eval { 
    $api_instance->interfaceLagSetupGet();
};
if ($@) {
    warn "Exception when calling InterfaceApi->interfaceLagSetupGet: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.InterfaceApi()

try: 
    api_instance.interface_lag_setup_get()
except ApiException as e:
    print("Exception when calling InterfaceApi->interfaceLagSetupGet: %s\n" % e)

Parameters

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


interfacePost

Create virtual interfaces (Link Aggregation, VLAN) For BRIDGE `type` the following attribute is required: bridge_members. For LINK_AGGREGATION `type` the following attributes are required: lag_ports, lag_protocol. For VLAN `type` the following attributes are required: vlan_parent_interface, vlan_tag and vlan_pcp.


/interface

Usage and SDK Samples

curl -X POST -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/interface"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.InterfaceApi;

import java.io.File;
import java.util.*;

public class InterfaceApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        InterfaceApi apiInstance = new InterfaceApi();
        Interface_create_0 body = ; // Interface_create_0 | 
        try {
            apiInstance.interfacePost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling InterfaceApi#interfacePost");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::InterfaceApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::InterfaceApi->new();
my $body = WWW::SwaggerClient::Object::Interface_create_0->new(); # Interface_create_0 | 

eval { 
    $api_instance->interfacePost(body => $body);
};
if ($@) {
    warn "Exception when calling InterfaceApi->interfacePost: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.InterfaceApi()
body =  # Interface_create_0 |  (optional)

try: 
    api_instance.interface_post(body=body)
except ApiException as e:
    print("Exception when calling InterfaceApi->interfacePost: %s\n" % e)

Parameters

Body parameters
Name Description
body

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


interfaceRollbackGet

Rollback pending interfaces changes.


/interface/rollback

Usage and SDK Samples

curl -X GET -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/interface/rollback"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.InterfaceApi;

import java.io.File;
import java.util.*;

public class InterfaceApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        InterfaceApi apiInstance = new InterfaceApi();
        try {
            apiInstance.interfaceRollbackGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling InterfaceApi#interfaceRollbackGet");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::InterfaceApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::InterfaceApi->new();

eval { 
    $api_instance->interfaceRollbackGet();
};
if ($@) {
    warn "Exception when calling InterfaceApi->interfaceRollbackGet: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.InterfaceApi()

try: 
    api_instance.interface_rollback_get()
except ApiException as e:
    print("Exception when calling InterfaceApi->interfaceRollbackGet: %s\n" % e)

Parameters

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


interfaceVlanParentInterfaceChoicesGet

Return available interface choices for `vlan_parent_interface` attribute.


/interface/vlan_parent_interface_choices

Usage and SDK Samples

curl -X GET -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/interface/vlan_parent_interface_choices"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.InterfaceApi;

import java.io.File;
import java.util.*;

public class InterfaceApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        InterfaceApi apiInstance = new InterfaceApi();
        try {
            apiInstance.interfaceVlanParentInterfaceChoicesGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling InterfaceApi#interfaceVlanParentInterfaceChoicesGet");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::InterfaceApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::InterfaceApi->new();

eval { 
    $api_instance->interfaceVlanParentInterfaceChoicesGet();
};
if ($@) {
    warn "Exception when calling InterfaceApi->interfaceVlanParentInterfaceChoicesGet: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.InterfaceApi()

try: 
    api_instance.interface_vlan_parent_interface_choices_get()
except ApiException as e:
    print("Exception when calling InterfaceApi->interfaceVlanParentInterfaceChoicesGet: %s\n" % e)

Parameters

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


interfaceVlanSetupGet


/interface/vlan_setup

Usage and SDK Samples

curl -X GET -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/interface/vlan_setup"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.InterfaceApi;

import java.io.File;
import java.util.*;

public class InterfaceApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        InterfaceApi apiInstance = new InterfaceApi();
        try {
            apiInstance.interfaceVlanSetupGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling InterfaceApi#interfaceVlanSetupGet");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::InterfaceApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::InterfaceApi->new();

eval { 
    $api_instance->interfaceVlanSetupGet();
};
if ($@) {
    warn "Exception when calling InterfaceApi->interfaceVlanSetupGet: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.InterfaceApi()

try: 
    api_instance.interface_vlan_setup_get()
except ApiException as e:
    print("Exception when calling InterfaceApi->interfaceVlanSetupGet: %s\n" % e)

Parameters

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


Ipmi

ipmiChannelsGet

Return a list with the IPMI channels available.


/ipmi/channels

Usage and SDK Samples

curl -X GET -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/ipmi/channels"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.IpmiApi;

import java.io.File;
import java.util.*;

public class IpmiApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        IpmiApi apiInstance = new IpmiApi();
        try {
            apiInstance.ipmiChannelsGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling IpmiApi#ipmiChannelsGet");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::IpmiApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::IpmiApi->new();

eval { 
    $api_instance->ipmiChannelsGet();
};
if ($@) {
    warn "Exception when calling IpmiApi->ipmiChannelsGet: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.IpmiApi()

try: 
    api_instance.ipmi_channels_get()
except ApiException as e:
    print("Exception when calling IpmiApi->ipmiChannelsGet: %s\n" % e)

Parameters

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


ipmiGet

Query all IPMI Channels with `query-filters` and `query-options`.


/ipmi

Usage and SDK Samples

curl -X GET -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/ipmi?limit=&offset=&count=&sort="
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.IpmiApi;

import java.io.File;
import java.util.*;

public class IpmiApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        IpmiApi apiInstance = new IpmiApi();
        Integer limit = 56; // Integer | 
        Integer offset = 56; // Integer | 
        Boolean count = true; // Boolean | 
        String sort = sort_example; // String | 
        try {
            apiInstance.ipmiGet(limit, offset, count, sort);
        } catch (ApiException e) {
            System.err.println("Exception when calling IpmiApi#ipmiGet");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::IpmiApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::IpmiApi->new();
my $limit = 56; # Integer | 
my $offset = 56; # Integer | 
my $count = true; # Boolean | 
my $sort = sort_example; # String | 

eval { 
    $api_instance->ipmiGet(limit => $limit, offset => $offset, count => $count, sort => $sort);
};
if ($@) {
    warn "Exception when calling IpmiApi->ipmiGet: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.IpmiApi()
limit = 56 # Integer |  (optional)
offset = 56 # Integer |  (optional)
count = true # Boolean |  (optional)
sort = sort_example # String |  (optional)

try: 
    api_instance.ipmi_get(limit=limit, offset=offset, count=count, sort=sort)
except ApiException as e:
    print("Exception when calling IpmiApi->ipmiGet: %s\n" % e)

Parameters

Query parameters
Name Description
limit
Integer
offset
Integer
count
Boolean
sort
String

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


ipmiIdIdGet

Query all IPMI Channels with `query-filters` and `query-options`.


/ipmi/id/{id}

Usage and SDK Samples

curl -X GET -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/ipmi/id/{id}?limit=&offset=&count=&sort="
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.IpmiApi;

import java.io.File;
import java.util.*;

public class IpmiApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        IpmiApi apiInstance = new IpmiApi();
        array[null] id = ; // array[null] | 
        Integer limit = 56; // Integer | 
        Integer offset = 56; // Integer | 
        Boolean count = true; // Boolean | 
        String sort = sort_example; // String | 
        try {
            apiInstance.ipmiIdIdGet(id, limit, offset, count, sort);
        } catch (ApiException e) {
            System.err.println("Exception when calling IpmiApi#ipmiIdIdGet");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::IpmiApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::IpmiApi->new();
my $id = []; # array[null] | 
my $limit = 56; # Integer | 
my $offset = 56; # Integer | 
my $count = true; # Boolean | 
my $sort = sort_example; # String | 

eval { 
    $api_instance->ipmiIdIdGet(id => $id, limit => $limit, offset => $offset, count => $count, sort => $sort);
};
if ($@) {
    warn "Exception when calling IpmiApi->ipmiIdIdGet: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.IpmiApi()
id =  # array[null] | 
limit = 56 # Integer |  (optional)
offset = 56 # Integer |  (optional)
count = true # Boolean |  (optional)
sort = sort_example # String |  (optional)

try: 
    api_instance.ipmi_id_id_get(id, limit=limit, offset=offset, count=count, sort=sort)
except ApiException as e:
    print("Exception when calling IpmiApi->ipmiIdIdGet: %s\n" % e)

Parameters

Path parameters
Name Description
id*
array[null]
Required
Query parameters
Name Description
limit
Integer
offset
Integer
count
Boolean
sort
String

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


ipmiIdIdPut

Update `id` IPMI Configuration. `ipaddress` is a valid ip which will be used to connect to the IPMI interface. `netmask` is the subnet mask associated with `ipaddress`. `dhcp` is a boolean value which if unset means that `ipaddress`, `netmask` and `gateway` must be set.


/ipmi/id/{id}

Usage and SDK Samples

curl -X PUT -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/ipmi/id/{id}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.IpmiApi;

import java.io.File;
import java.util.*;

public class IpmiApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        IpmiApi apiInstance = new IpmiApi();
        Integer id = 56; // Integer | 
        Ipmi_update_1 body = ; // Ipmi_update_1 | 
        try {
            apiInstance.ipmiIdIdPut(id, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling IpmiApi#ipmiIdIdPut");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::IpmiApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::IpmiApi->new();
my $id = 56; # Integer | 
my $body = WWW::SwaggerClient::Object::Ipmi_update_1->new(); # Ipmi_update_1 | 

eval { 
    $api_instance->ipmiIdIdPut(id => $id, body => $body);
};
if ($@) {
    warn "Exception when calling IpmiApi->ipmiIdIdPut: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.IpmiApi()
id = 56 # Integer | 
body =  # Ipmi_update_1 |  (optional)

try: 
    api_instance.ipmi_id_id_put(id, body=body)
except ApiException as e:
    print("Exception when calling IpmiApi->ipmiIdIdPut: %s\n" % e)

Parameters

Path parameters
Name Description
id*
Integer
Required
Body parameters
Name Description
body

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


ipmiIdentifyPost

Turn on IPMI chassis identify light. To turn off specify 0 as `seconds`.


/ipmi/identify

Usage and SDK Samples

curl -X POST -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/ipmi/identify"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.IpmiApi;

import java.io.File;
import java.util.*;

public class IpmiApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        IpmiApi apiInstance = new IpmiApi();
        Ipmi_identify_0 body = ; // Ipmi_identify_0 | 
        try {
            apiInstance.ipmiIdentifyPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling IpmiApi#ipmiIdentifyPost");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::IpmiApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::IpmiApi->new();
my $body = WWW::SwaggerClient::Object::Ipmi_identify_0->new(); # Ipmi_identify_0 | 

eval { 
    $api_instance->ipmiIdentifyPost(body => $body);
};
if ($@) {
    warn "Exception when calling IpmiApi->ipmiIdentifyPost: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.IpmiApi()
body =  # Ipmi_identify_0 |  (optional)

try: 
    api_instance.ipmi_identify_post(body=body)
except ApiException as e:
    print("Exception when calling IpmiApi->ipmiIdentifyPost: %s\n" % e)

Parameters

Body parameters
Name Description
body

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


ipmiIsLoadedGet

Returns a boolean true value indicating if ipmi device is loaded.


/ipmi/is_loaded

Usage and SDK Samples

curl -X GET -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/ipmi/is_loaded"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.IpmiApi;

import java.io.File;
import java.util.*;

public class IpmiApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        IpmiApi apiInstance = new IpmiApi();
        try {
            apiInstance.ipmiIsLoadedGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling IpmiApi#ipmiIsLoadedGet");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::IpmiApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::IpmiApi->new();

eval { 
    $api_instance->ipmiIsLoadedGet();
};
if ($@) {
    warn "Exception when calling IpmiApi->ipmiIsLoadedGet: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.IpmiApi()

try: 
    api_instance.ipmi_is_loaded_get()
except ApiException as e:
    print("Exception when calling IpmiApi->ipmiIsLoadedGet: %s\n" % e)

Parameters

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


IscsiAuth

iscsiAuthGet


/iscsi/auth

Usage and SDK Samples

curl -X GET -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/iscsi/auth?limit=&offset=&count=&sort="
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.IscsiAuthApi;

import java.io.File;
import java.util.*;

public class IscsiAuthApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        IscsiAuthApi apiInstance = new IscsiAuthApi();
        Integer limit = 56; // Integer | 
        Integer offset = 56; // Integer | 
        Boolean count = true; // Boolean | 
        String sort = sort_example; // String | 
        try {
            apiInstance.iscsiAuthGet(limit, offset, count, sort);
        } catch (ApiException e) {
            System.err.println("Exception when calling IscsiAuthApi#iscsiAuthGet");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::IscsiAuthApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::IscsiAuthApi->new();
my $limit = 56; # Integer | 
my $offset = 56; # Integer | 
my $count = true; # Boolean | 
my $sort = sort_example; # String | 

eval { 
    $api_instance->iscsiAuthGet(limit => $limit, offset => $offset, count => $count, sort => $sort);
};
if ($@) {
    warn "Exception when calling IscsiAuthApi->iscsiAuthGet: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.IscsiAuthApi()
limit = 56 # Integer |  (optional)
offset = 56 # Integer |  (optional)
count = true # Boolean |  (optional)
sort = sort_example # String |  (optional)

try: 
    api_instance.iscsi_auth_get(limit=limit, offset=offset, count=count, sort=sort)
except ApiException as e:
    print("Exception when calling IscsiAuthApi->iscsiAuthGet: %s\n" % e)

Parameters

Query parameters
Name Description
limit
Integer
offset
Integer
count
Boolean
sort
String

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


iscsiAuthIdIdDelete

Delete iSCSI Authorized Access of `id`.


/iscsi/auth/id/{id}

Usage and SDK Samples

curl -X DELETE -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/iscsi/auth/id/{id}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.IscsiAuthApi;

import java.io.File;
import java.util.*;

public class IscsiAuthApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        IscsiAuthApi apiInstance = new IscsiAuthApi();
        Integer id = 56; // Integer | 
        try {
            apiInstance.iscsiAuthIdIdDelete(id);
        } catch (ApiException e) {
            System.err.println("Exception when calling IscsiAuthApi#iscsiAuthIdIdDelete");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::IscsiAuthApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::IscsiAuthApi->new();
my $id = 56; # Integer | 

eval { 
    $api_instance->iscsiAuthIdIdDelete(id => $id);
};
if ($@) {
    warn "Exception when calling IscsiAuthApi->iscsiAuthIdIdDelete: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.IscsiAuthApi()
id = 56 # Integer | 

try: 
    api_instance.iscsi_auth_id_id_delete(id)
except ApiException as e:
    print("Exception when calling IscsiAuthApi->iscsiAuthIdIdDelete: %s\n" % e)

Parameters

Path parameters
Name Description
id*
Integer
Required

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


iscsiAuthIdIdGet


/iscsi/auth/id/{id}

Usage and SDK Samples

curl -X GET -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/iscsi/auth/id/{id}?limit=&offset=&count=&sort="
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.IscsiAuthApi;

import java.io.File;
import java.util.*;

public class IscsiAuthApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        IscsiAuthApi apiInstance = new IscsiAuthApi();
        array[null] id = ; // array[null] | 
        Integer limit = 56; // Integer | 
        Integer offset = 56; // Integer | 
        Boolean count = true; // Boolean | 
        String sort = sort_example; // String | 
        try {
            apiInstance.iscsiAuthIdIdGet(id, limit, offset, count, sort);
        } catch (ApiException e) {
            System.err.println("Exception when calling IscsiAuthApi#iscsiAuthIdIdGet");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::IscsiAuthApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::IscsiAuthApi->new();
my $id = []; # array[null] | 
my $limit = 56; # Integer | 
my $offset = 56; # Integer | 
my $count = true; # Boolean | 
my $sort = sort_example; # String | 

eval { 
    $api_instance->iscsiAuthIdIdGet(id => $id, limit => $limit, offset => $offset, count => $count, sort => $sort);
};
if ($@) {
    warn "Exception when calling IscsiAuthApi->iscsiAuthIdIdGet: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.IscsiAuthApi()
id =  # array[null] | 
limit = 56 # Integer |  (optional)
offset = 56 # Integer |  (optional)
count = true # Boolean |  (optional)
sort = sort_example # String |  (optional)

try: 
    api_instance.iscsi_auth_id_id_get(id, limit=limit, offset=offset, count=count, sort=sort)
except ApiException as e:
    print("Exception when calling IscsiAuthApi->iscsiAuthIdIdGet: %s\n" % e)

Parameters

Path parameters
Name Description
id*
array[null]
Required
Query parameters
Name Description
limit
Integer
offset
Integer
count
Boolean
sort
String

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


iscsiAuthIdIdPut

Update iSCSI Authorized Access of `id`.


/iscsi/auth/id/{id}

Usage and SDK Samples

curl -X PUT -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/iscsi/auth/id/{id}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.IscsiAuthApi;

import java.io.File;
import java.util.*;

public class IscsiAuthApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        IscsiAuthApi apiInstance = new IscsiAuthApi();
        Integer id = 56; // Integer | 
        Iscsi_auth_update_1 body = ; // Iscsi_auth_update_1 | 
        try {
            apiInstance.iscsiAuthIdIdPut(id, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling IscsiAuthApi#iscsiAuthIdIdPut");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::IscsiAuthApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::IscsiAuthApi->new();
my $id = 56; # Integer | 
my $body = WWW::SwaggerClient::Object::Iscsi_auth_update_1->new(); # Iscsi_auth_update_1 | 

eval { 
    $api_instance->iscsiAuthIdIdPut(id => $id, body => $body);
};
if ($@) {
    warn "Exception when calling IscsiAuthApi->iscsiAuthIdIdPut: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.IscsiAuthApi()
id = 56 # Integer | 
body =  # Iscsi_auth_update_1 |  (optional)

try: 
    api_instance.iscsi_auth_id_id_put(id, body=body)
except ApiException as e:
    print("Exception when calling IscsiAuthApi->iscsiAuthIdIdPut: %s\n" % e)

Parameters

Path parameters
Name Description
id*
Integer
Required
Body parameters
Name Description
body

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


iscsiAuthPost

Create an iSCSI Authorized Access. `tag` should be unique among all configured iSCSI Authorized Accesses. `secret` and `peersecret` should have length between 12-16 letters inclusive. `peeruser` and `peersecret` are provided only when configuring mutual CHAP. `peersecret` should not be similar to `secret`.


/iscsi/auth

Usage and SDK Samples

curl -X POST -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/iscsi/auth"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.IscsiAuthApi;

import java.io.File;
import java.util.*;

public class IscsiAuthApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        IscsiAuthApi apiInstance = new IscsiAuthApi();
        Iscsi_auth_create_0 body = ; // Iscsi_auth_create_0 | 
        try {
            apiInstance.iscsiAuthPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling IscsiAuthApi#iscsiAuthPost");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::IscsiAuthApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::IscsiAuthApi->new();
my $body = WWW::SwaggerClient::Object::Iscsi_auth_create_0->new(); # Iscsi_auth_create_0 | 

eval { 
    $api_instance->iscsiAuthPost(body => $body);
};
if ($@) {
    warn "Exception when calling IscsiAuthApi->iscsiAuthPost: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.IscsiAuthApi()
body =  # Iscsi_auth_create_0 |  (optional)

try: 
    api_instance.iscsi_auth_post(body=body)
except ApiException as e:
    print("Exception when calling IscsiAuthApi->iscsiAuthPost: %s\n" % e)

Parameters

Body parameters
Name Description
body

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


IscsiExtent

iscsiExtentDiskChoicesPost

Exclude will exclude the path from being in the used_zvols list, allowing the user to keep the same item on update


/iscsi/extent/disk_choices

Usage and SDK Samples

curl -X POST -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/iscsi/extent/disk_choices"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.IscsiExtentApi;

import java.io.File;
import java.util.*;

public class IscsiExtentApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        IscsiExtentApi apiInstance = new IscsiExtentApi();
        array[null] body = ; // array[null] | 
        try {
            apiInstance.iscsiExtentDiskChoicesPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling IscsiExtentApi#iscsiExtentDiskChoicesPost");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::IscsiExtentApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::IscsiExtentApi->new();
my $body = [WWW::SwaggerClient::Object::array[null]->new()]; # array[null] | 

eval { 
    $api_instance->iscsiExtentDiskChoicesPost(body => $body);
};
if ($@) {
    warn "Exception when calling IscsiExtentApi->iscsiExtentDiskChoicesPost: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.IscsiExtentApi()
body =  # array[null] |  (optional)

try: 
    api_instance.iscsi_extent_disk_choices_post(body=body)
except ApiException as e:
    print("Exception when calling IscsiExtentApi->iscsiExtentDiskChoicesPost: %s\n" % e)

Parameters

Body parameters
Name Description
body

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


iscsiExtentGet


/iscsi/extent

Usage and SDK Samples

curl -X GET -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/iscsi/extent?limit=&offset=&count=&sort="
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.IscsiExtentApi;

import java.io.File;
import java.util.*;

public class IscsiExtentApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        IscsiExtentApi apiInstance = new IscsiExtentApi();
        Integer limit = 56; // Integer | 
        Integer offset = 56; // Integer | 
        Boolean count = true; // Boolean | 
        String sort = sort_example; // String | 
        try {
            apiInstance.iscsiExtentGet(limit, offset, count, sort);
        } catch (ApiException e) {
            System.err.println("Exception when calling IscsiExtentApi#iscsiExtentGet");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::IscsiExtentApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::IscsiExtentApi->new();
my $limit = 56; # Integer | 
my $offset = 56; # Integer | 
my $count = true; # Boolean | 
my $sort = sort_example; # String | 

eval { 
    $api_instance->iscsiExtentGet(limit => $limit, offset => $offset, count => $count, sort => $sort);
};
if ($@) {
    warn "Exception when calling IscsiExtentApi->iscsiExtentGet: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.IscsiExtentApi()
limit = 56 # Integer |  (optional)
offset = 56 # Integer |  (optional)
count = true # Boolean |  (optional)
sort = sort_example # String |  (optional)

try: 
    api_instance.iscsi_extent_get(limit=limit, offset=offset, count=count, sort=sort)
except ApiException as e:
    print("Exception when calling IscsiExtentApi->iscsiExtentGet: %s\n" % e)

Parameters

Query parameters
Name Description
limit
Integer
offset
Integer
count
Boolean
sort
String

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


iscsiExtentIdIdDelete

Delete iSCSI Extent of `id`. If `id` iSCSI Extent's `type` was configured to FILE, `remove` can be set to remove the configured file.


/iscsi/extent/id/{id}

Usage and SDK Samples

curl -X DELETE -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/iscsi/extent/id/{id}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.IscsiExtentApi;

import java.io.File;
import java.util.*;

public class IscsiExtentApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        IscsiExtentApi apiInstance = new IscsiExtentApi();
        Integer id = 56; // Integer | 
        Iscsi_extent_delete body = ; // Iscsi_extent_delete | 
        try {
            apiInstance.iscsiExtentIdIdDelete(id, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling IscsiExtentApi#iscsiExtentIdIdDelete");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::IscsiExtentApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::IscsiExtentApi->new();
my $id = 56; # Integer | 
my $body = WWW::SwaggerClient::Object::Iscsi_extent_delete->new(); # Iscsi_extent_delete | 

eval { 
    $api_instance->iscsiExtentIdIdDelete(id => $id, body => $body);
};
if ($@) {
    warn "Exception when calling IscsiExtentApi->iscsiExtentIdIdDelete: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.IscsiExtentApi()
id = 56 # Integer | 
body =  # Iscsi_extent_delete |  (optional)

try: 
    api_instance.iscsi_extent_id_id_delete(id, body=body)
except ApiException as e:
    print("Exception when calling IscsiExtentApi->iscsiExtentIdIdDelete: %s\n" % e)

Parameters

Path parameters
Name Description
id*
Integer
Required
Body parameters
Name Description
body

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


iscsiExtentIdIdGet


/iscsi/extent/id/{id}

Usage and SDK Samples

curl -X GET -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/iscsi/extent/id/{id}?limit=&offset=&count=&sort="
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.IscsiExtentApi;

import java.io.File;
import java.util.*;

public class IscsiExtentApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        IscsiExtentApi apiInstance = new IscsiExtentApi();
        array[null] id = ; // array[null] | 
        Integer limit = 56; // Integer | 
        Integer offset = 56; // Integer | 
        Boolean count = true; // Boolean | 
        String sort = sort_example; // String | 
        try {
            apiInstance.iscsiExtentIdIdGet(id, limit, offset, count, sort);
        } catch (ApiException e) {
            System.err.println("Exception when calling IscsiExtentApi#iscsiExtentIdIdGet");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::IscsiExtentApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::IscsiExtentApi->new();
my $id = []; # array[null] | 
my $limit = 56; # Integer | 
my $offset = 56; # Integer | 
my $count = true; # Boolean | 
my $sort = sort_example; # String | 

eval { 
    $api_instance->iscsiExtentIdIdGet(id => $id, limit => $limit, offset => $offset, count => $count, sort => $sort);
};
if ($@) {
    warn "Exception when calling IscsiExtentApi->iscsiExtentIdIdGet: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.IscsiExtentApi()
id =  # array[null] | 
limit = 56 # Integer |  (optional)
offset = 56 # Integer |  (optional)
count = true # Boolean |  (optional)
sort = sort_example # String |  (optional)

try: 
    api_instance.iscsi_extent_id_id_get(id, limit=limit, offset=offset, count=count, sort=sort)
except ApiException as e:
    print("Exception when calling IscsiExtentApi->iscsiExtentIdIdGet: %s\n" % e)

Parameters

Path parameters
Name Description
id*
array[null]
Required
Query parameters
Name Description
limit
Integer
offset
Integer
count
Boolean
sort
String

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


iscsiExtentIdIdPut

Update iSCSI Extent of `id`.


/iscsi/extent/id/{id}

Usage and SDK Samples

curl -X PUT -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/iscsi/extent/id/{id}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.IscsiExtentApi;

import java.io.File;
import java.util.*;

public class IscsiExtentApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        IscsiExtentApi apiInstance = new IscsiExtentApi();
        Integer id = 56; // Integer | 
        Iscsi_extent_update_1 body = ; // Iscsi_extent_update_1 | 
        try {
            apiInstance.iscsiExtentIdIdPut(id, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling IscsiExtentApi#iscsiExtentIdIdPut");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::IscsiExtentApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::IscsiExtentApi->new();
my $id = 56; # Integer | 
my $body = WWW::SwaggerClient::Object::Iscsi_extent_update_1->new(); # Iscsi_extent_update_1 | 

eval { 
    $api_instance->iscsiExtentIdIdPut(id => $id, body => $body);
};
if ($@) {
    warn "Exception when calling IscsiExtentApi->iscsiExtentIdIdPut: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.IscsiExtentApi()
id = 56 # Integer | 
body =  # Iscsi_extent_update_1 |  (optional)

try: 
    api_instance.iscsi_extent_id_id_put(id, body=body)
except ApiException as e:
    print("Exception when calling IscsiExtentApi->iscsiExtentIdIdPut: %s\n" % e)

Parameters

Path parameters
Name Description
id*
Integer
Required
Body parameters
Name Description
body

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


iscsiExtentPost

Create an iSCSI Extent. When `type` is set to FILE, attribute `filesize` is used and it represents number of bytes. `filesize` if not zero should be a multiple of `blocksize`. `path` is a required attribute with `type` set as FILE and it should be ensured that it does not come under a jail root. With `type` being set to DISK, a valid ZVOL or DISK should be provided. `insecure_tpc` when enabled allows an initiator to bypass normal access control and access any scannable target. This allows xcopy operations otherwise blocked by access control. `xen` is a boolean value which is set to true if Xen is being used as the iSCSI initiator. `ro` when set to true prevents the initiator from writing to this LUN.


/iscsi/extent

Usage and SDK Samples

curl -X POST -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/iscsi/extent"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.IscsiExtentApi;

import java.io.File;
import java.util.*;

public class IscsiExtentApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        IscsiExtentApi apiInstance = new IscsiExtentApi();
        Iscsi_extent_create_0 body = ; // Iscsi_extent_create_0 | 
        try {
            apiInstance.iscsiExtentPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling IscsiExtentApi#iscsiExtentPost");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::IscsiExtentApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::IscsiExtentApi->new();
my $body = WWW::SwaggerClient::Object::Iscsi_extent_create_0->new(); # Iscsi_extent_create_0 | 

eval { 
    $api_instance->iscsiExtentPost(body => $body);
};
if ($@) {
    warn "Exception when calling IscsiExtentApi->iscsiExtentPost: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.IscsiExtentApi()
body =  # Iscsi_extent_create_0 |  (optional)

try: 
    api_instance.iscsi_extent_post(body=body)
except ApiException as e:
    print("Exception when calling IscsiExtentApi->iscsiExtentPost: %s\n" % e)

Parameters

Body parameters
Name Description
body

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


IscsiGlobal

iscsiGlobalAluaEnabledGet

Returns whether iSCSI ALUA is enabled or not.


/iscsi/global/alua_enabled

Usage and SDK Samples

curl -X GET -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/iscsi/global/alua_enabled"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.IscsiGlobalApi;

import java.io.File;
import java.util.*;

public class IscsiGlobalApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        IscsiGlobalApi apiInstance = new IscsiGlobalApi();
        try {
            apiInstance.iscsiGlobalAluaEnabledGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling IscsiGlobalApi#iscsiGlobalAluaEnabledGet");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::IscsiGlobalApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::IscsiGlobalApi->new();

eval { 
    $api_instance->iscsiGlobalAluaEnabledGet();
};
if ($@) {
    warn "Exception when calling IscsiGlobalApi->iscsiGlobalAluaEnabledGet: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.IscsiGlobalApi()

try: 
    api_instance.iscsi_global_alua_enabled_get()
except ApiException as e:
    print("Exception when calling IscsiGlobalApi->iscsiGlobalAluaEnabledGet: %s\n" % e)

Parameters

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


iscsiGlobalGet


/iscsi/global

Usage and SDK Samples

curl -X GET -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/iscsi/global"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.IscsiGlobalApi;

import java.io.File;
import java.util.*;

public class IscsiGlobalApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        IscsiGlobalApi apiInstance = new IscsiGlobalApi();
        try {
            apiInstance.iscsiGlobalGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling IscsiGlobalApi#iscsiGlobalGet");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::IscsiGlobalApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::IscsiGlobalApi->new();

eval { 
    $api_instance->iscsiGlobalGet();
};
if ($@) {
    warn "Exception when calling IscsiGlobalApi->iscsiGlobalGet: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.IscsiGlobalApi()

try: 
    api_instance.iscsi_global_get()
except ApiException as e:
    print("Exception when calling IscsiGlobalApi->iscsiGlobalGet: %s\n" % e)

Parameters

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


iscsiGlobalPut

`alua` is a no-op for FreeNAS.


/iscsi/global

Usage and SDK Samples

curl -X PUT -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/iscsi/global"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.IscsiGlobalApi;

import java.io.File;
import java.util.*;

public class IscsiGlobalApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        IscsiGlobalApi apiInstance = new IscsiGlobalApi();
        Iscsi_global_update_0 body = ; // Iscsi_global_update_0 | 
        try {
            apiInstance.iscsiGlobalPut(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling IscsiGlobalApi#iscsiGlobalPut");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::IscsiGlobalApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::IscsiGlobalApi->new();
my $body = WWW::SwaggerClient::Object::Iscsi_global_update_0->new(); # Iscsi_global_update_0 | 

eval { 
    $api_instance->iscsiGlobalPut(body => $body);
};
if ($@) {
    warn "Exception when calling IscsiGlobalApi->iscsiGlobalPut: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.IscsiGlobalApi()
body =  # Iscsi_global_update_0 |  (optional)

try: 
    api_instance.iscsi_global_put(body=body)
except ApiException as e:
    print("Exception when calling IscsiGlobalApi->iscsiGlobalPut: %s\n" % e)

Parameters

Body parameters
Name Description
body

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


iscsiGlobalSessionsGet

Get a list of currently running iSCSI sessions. This includes initiator and target names and the unique connection IDs.


/iscsi/global/sessions

Usage and SDK Samples

curl -X GET -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/iscsi/global/sessions?limit=&offset=&count=&sort="
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.IscsiGlobalApi;

import java.io.File;
import java.util.*;

public class IscsiGlobalApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        IscsiGlobalApi apiInstance = new IscsiGlobalApi();
        Integer limit = 56; // Integer | 
        Integer offset = 56; // Integer | 
        Boolean count = true; // Boolean | 
        String sort = sort_example; // String | 
        try {
            apiInstance.iscsiGlobalSessionsGet(limit, offset, count, sort);
        } catch (ApiException e) {
            System.err.println("Exception when calling IscsiGlobalApi#iscsiGlobalSessionsGet");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::IscsiGlobalApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::IscsiGlobalApi->new();
my $limit = 56; # Integer | 
my $offset = 56; # Integer | 
my $count = true; # Boolean | 
my $sort = sort_example; # String | 

eval { 
    $api_instance->iscsiGlobalSessionsGet(limit => $limit, offset => $offset, count => $count, sort => $sort);
};
if ($@) {
    warn "Exception when calling IscsiGlobalApi->iscsiGlobalSessionsGet: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.IscsiGlobalApi()
limit = 56 # Integer |  (optional)
offset = 56 # Integer |  (optional)
count = true # Boolean |  (optional)
sort = sort_example # String |  (optional)

try: 
    api_instance.iscsi_global_sessions_get(limit=limit, offset=offset, count=count, sort=sort)
except ApiException as e:
    print("Exception when calling IscsiGlobalApi->iscsiGlobalSessionsGet: %s\n" % e)

Parameters

Query parameters
Name Description
limit
Integer
offset
Integer
count
Boolean
sort
String

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


IscsiInitiator

iscsiInitiatorGet


/iscsi/initiator

Usage and SDK Samples

curl -X GET -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/iscsi/initiator?limit=&offset=&count=&sort="
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.IscsiInitiatorApi;

import java.io.File;
import java.util.*;

public class IscsiInitiatorApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        IscsiInitiatorApi apiInstance = new IscsiInitiatorApi();
        Integer limit = 56; // Integer | 
        Integer offset = 56; // Integer | 
        Boolean count = true; // Boolean | 
        String sort = sort_example; // String | 
        try {
            apiInstance.iscsiInitiatorGet(limit, offset, count, sort);
        } catch (ApiException e) {
            System.err.println("Exception when calling IscsiInitiatorApi#iscsiInitiatorGet");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::IscsiInitiatorApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::IscsiInitiatorApi->new();
my $limit = 56; # Integer | 
my $offset = 56; # Integer | 
my $count = true; # Boolean | 
my $sort = sort_example; # String | 

eval { 
    $api_instance->iscsiInitiatorGet(limit => $limit, offset => $offset, count => $count, sort => $sort);
};
if ($@) {
    warn "Exception when calling IscsiInitiatorApi->iscsiInitiatorGet: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.IscsiInitiatorApi()
limit = 56 # Integer |  (optional)
offset = 56 # Integer |  (optional)
count = true # Boolean |  (optional)
sort = sort_example # String |  (optional)

try: 
    api_instance.iscsi_initiator_get(limit=limit, offset=offset, count=count, sort=sort)
except ApiException as e:
    print("Exception when calling IscsiInitiatorApi->iscsiInitiatorGet: %s\n" % e)

Parameters

Query parameters
Name Description
limit
Integer
offset
Integer
count
Boolean
sort
String

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


iscsiInitiatorIdIdDelete

Delete iSCSI initiator of `id`.


/iscsi/initiator/id/{id}

Usage and SDK Samples

curl -X DELETE -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/iscsi/initiator/id/{id}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.IscsiInitiatorApi;

import java.io.File;
import java.util.*;

public class IscsiInitiatorApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        IscsiInitiatorApi apiInstance = new IscsiInitiatorApi();
        Integer id = 56; // Integer | 
        try {
            apiInstance.iscsiInitiatorIdIdDelete(id);
        } catch (ApiException e) {
            System.err.println("Exception when calling IscsiInitiatorApi#iscsiInitiatorIdIdDelete");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::IscsiInitiatorApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::IscsiInitiatorApi->new();
my $id = 56; # Integer | 

eval { 
    $api_instance->iscsiInitiatorIdIdDelete(id => $id);
};
if ($@) {
    warn "Exception when calling IscsiInitiatorApi->iscsiInitiatorIdIdDelete: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.IscsiInitiatorApi()
id = 56 # Integer | 

try: 
    api_instance.iscsi_initiator_id_id_delete(id)
except ApiException as e:
    print("Exception when calling IscsiInitiatorApi->iscsiInitiatorIdIdDelete: %s\n" % e)

Parameters

Path parameters
Name Description
id*
Integer
Required

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


iscsiInitiatorIdIdGet


/iscsi/initiator/id/{id}

Usage and SDK Samples

curl -X GET -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/iscsi/initiator/id/{id}?limit=&offset=&count=&sort="
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.IscsiInitiatorApi;

import java.io.File;
import java.util.*;

public class IscsiInitiatorApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        IscsiInitiatorApi apiInstance = new IscsiInitiatorApi();
        array[null] id = ; // array[null] | 
        Integer limit = 56; // Integer | 
        Integer offset = 56; // Integer | 
        Boolean count = true; // Boolean | 
        String sort = sort_example; // String | 
        try {
            apiInstance.iscsiInitiatorIdIdGet(id, limit, offset, count, sort);
        } catch (ApiException e) {
            System.err.println("Exception when calling IscsiInitiatorApi#iscsiInitiatorIdIdGet");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::IscsiInitiatorApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::IscsiInitiatorApi->new();
my $id = []; # array[null] | 
my $limit = 56; # Integer | 
my $offset = 56; # Integer | 
my $count = true; # Boolean | 
my $sort = sort_example; # String | 

eval { 
    $api_instance->iscsiInitiatorIdIdGet(id => $id, limit => $limit, offset => $offset, count => $count, sort => $sort);
};
if ($@) {
    warn "Exception when calling IscsiInitiatorApi->iscsiInitiatorIdIdGet: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.IscsiInitiatorApi()
id =  # array[null] | 
limit = 56 # Integer |  (optional)
offset = 56 # Integer |  (optional)
count = true # Boolean |  (optional)
sort = sort_example # String |  (optional)

try: 
    api_instance.iscsi_initiator_id_id_get(id, limit=limit, offset=offset, count=count, sort=sort)
except ApiException as e:
    print("Exception when calling IscsiInitiatorApi->iscsiInitiatorIdIdGet: %s\n" % e)

Parameters

Path parameters
Name Description
id*
array[null]
Required
Query parameters
Name Description
limit
Integer
offset
Integer
count
Boolean
sort
String

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


iscsiInitiatorIdIdPut

Update iSCSI initiator of `id`.


/iscsi/initiator/id/{id}

Usage and SDK Samples

curl -X PUT -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/iscsi/initiator/id/{id}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.IscsiInitiatorApi;

import java.io.File;
import java.util.*;

public class IscsiInitiatorApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        IscsiInitiatorApi apiInstance = new IscsiInitiatorApi();
        Integer id = 56; // Integer | 
        Iscsi_initiator_update_1 body = ; // Iscsi_initiator_update_1 | 
        try {
            apiInstance.iscsiInitiatorIdIdPut(id, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling IscsiInitiatorApi#iscsiInitiatorIdIdPut");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::IscsiInitiatorApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::IscsiInitiatorApi->new();
my $id = 56; # Integer | 
my $body = WWW::SwaggerClient::Object::Iscsi_initiator_update_1->new(); # Iscsi_initiator_update_1 | 

eval { 
    $api_instance->iscsiInitiatorIdIdPut(id => $id, body => $body);
};
if ($@) {
    warn "Exception when calling IscsiInitiatorApi->iscsiInitiatorIdIdPut: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.IscsiInitiatorApi()
id = 56 # Integer | 
body =  # Iscsi_initiator_update_1 |  (optional)

try: 
    api_instance.iscsi_initiator_id_id_put(id, body=body)
except ApiException as e:
    print("Exception when calling IscsiInitiatorApi->iscsiInitiatorIdIdPut: %s\n" % e)

Parameters

Path parameters
Name Description
id*
Integer
Required
Body parameters
Name Description
body

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


iscsiInitiatorPost

Create an iSCSI Initiator. `initiators` is a list of initiator hostnames which are authorized to access an iSCSI Target. To allow all possible initiators, `initiators` can be left empty. `auth_network` is a list of IP/CIDR addresses which are allowed to use this initiator. If all networks are to be allowed, this field should be left empty.


/iscsi/initiator

Usage and SDK Samples

curl -X POST -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/iscsi/initiator"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.IscsiInitiatorApi;

import java.io.File;
import java.util.*;

public class IscsiInitiatorApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        IscsiInitiatorApi apiInstance = new IscsiInitiatorApi();
        Iscsi_initiator_create_0 body = ; // Iscsi_initiator_create_0 | 
        try {
            apiInstance.iscsiInitiatorPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling IscsiInitiatorApi#iscsiInitiatorPost");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::IscsiInitiatorApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::IscsiInitiatorApi->new();
my $body = WWW::SwaggerClient::Object::Iscsi_initiator_create_0->new(); # Iscsi_initiator_create_0 | 

eval { 
    $api_instance->iscsiInitiatorPost(body => $body);
};
if ($@) {
    warn "Exception when calling IscsiInitiatorApi->iscsiInitiatorPost: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.IscsiInitiatorApi()
body =  # Iscsi_initiator_create_0 |  (optional)

try: 
    api_instance.iscsi_initiator_post(body=body)
except ApiException as e:
    print("Exception when calling IscsiInitiatorApi->iscsiInitiatorPost: %s\n" % e)

Parameters

Body parameters
Name Description
body

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


IscsiPortal

iscsiPortalGet


/iscsi/portal

Usage and SDK Samples

curl -X GET -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/iscsi/portal?limit=&offset=&count=&sort="
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.IscsiPortalApi;

import java.io.File;
import java.util.*;

public class IscsiPortalApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        IscsiPortalApi apiInstance = new IscsiPortalApi();
        Integer limit = 56; // Integer | 
        Integer offset = 56; // Integer | 
        Boolean count = true; // Boolean | 
        String sort = sort_example; // String | 
        try {
            apiInstance.iscsiPortalGet(limit, offset, count, sort);
        } catch (ApiException e) {
            System.err.println("Exception when calling IscsiPortalApi#iscsiPortalGet");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::IscsiPortalApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::IscsiPortalApi->new();
my $limit = 56; # Integer | 
my $offset = 56; # Integer | 
my $count = true; # Boolean | 
my $sort = sort_example; # String | 

eval { 
    $api_instance->iscsiPortalGet(limit => $limit, offset => $offset, count => $count, sort => $sort);
};
if ($@) {
    warn "Exception when calling IscsiPortalApi->iscsiPortalGet: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.IscsiPortalApi()
limit = 56 # Integer |  (optional)
offset = 56 # Integer |  (optional)
count = true # Boolean |  (optional)
sort = sort_example # String |  (optional)

try: 
    api_instance.iscsi_portal_get(limit=limit, offset=offset, count=count, sort=sort)
except ApiException as e:
    print("Exception when calling IscsiPortalApi->iscsiPortalGet: %s\n" % e)

Parameters

Query parameters
Name Description
limit
Integer
offset
Integer
count
Boolean
sort
String

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


iscsiPortalIdIdDelete

Delete iSCSI Portal `id`.


/iscsi/portal/id/{id}

Usage and SDK Samples

curl -X DELETE -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/iscsi/portal/id/{id}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.IscsiPortalApi;

import java.io.File;
import java.util.*;

public class IscsiPortalApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        IscsiPortalApi apiInstance = new IscsiPortalApi();
        Integer id = 56; // Integer | 
        try {
            apiInstance.iscsiPortalIdIdDelete(id);
        } catch (ApiException e) {
            System.err.println("Exception when calling IscsiPortalApi#iscsiPortalIdIdDelete");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::IscsiPortalApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::IscsiPortalApi->new();
my $id = 56; # Integer | 

eval { 
    $api_instance->iscsiPortalIdIdDelete(id => $id);
};
if ($@) {
    warn "Exception when calling IscsiPortalApi->iscsiPortalIdIdDelete: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.IscsiPortalApi()
id = 56 # Integer | 

try: 
    api_instance.iscsi_portal_id_id_delete(id)
except ApiException as e:
    print("Exception when calling IscsiPortalApi->iscsiPortalIdIdDelete: %s\n" % e)

Parameters

Path parameters
Name Description
id*
Integer
Required

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


iscsiPortalIdIdGet


/iscsi/portal/id/{id}

Usage and SDK Samples

curl -X GET -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/iscsi/portal/id/{id}?limit=&offset=&count=&sort="
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.IscsiPortalApi;

import java.io.File;
import java.util.*;

public class IscsiPortalApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        IscsiPortalApi apiInstance = new IscsiPortalApi();
        array[null] id = ; // array[null] | 
        Integer limit = 56; // Integer | 
        Integer offset = 56; // Integer | 
        Boolean count = true; // Boolean | 
        String sort = sort_example; // String | 
        try {
            apiInstance.iscsiPortalIdIdGet(id, limit, offset, count, sort);
        } catch (ApiException e) {
            System.err.println("Exception when calling IscsiPortalApi#iscsiPortalIdIdGet");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::IscsiPortalApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::IscsiPortalApi->new();
my $id = []; # array[null] | 
my $limit = 56; # Integer | 
my $offset = 56; # Integer | 
my $count = true; # Boolean | 
my $sort = sort_example; # String | 

eval { 
    $api_instance->iscsiPortalIdIdGet(id => $id, limit => $limit, offset => $offset, count => $count, sort => $sort);
};
if ($@) {
    warn "Exception when calling IscsiPortalApi->iscsiPortalIdIdGet: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.IscsiPortalApi()
id =  # array[null] | 
limit = 56 # Integer |  (optional)
offset = 56 # Integer |  (optional)
count = true # Boolean |  (optional)
sort = sort_example # String |  (optional)

try: 
    api_instance.iscsi_portal_id_id_get(id, limit=limit, offset=offset, count=count, sort=sort)
except ApiException as e:
    print("Exception when calling IscsiPortalApi->iscsiPortalIdIdGet: %s\n" % e)

Parameters

Path parameters
Name Description
id*
array[null]
Required
Query parameters
Name Description
limit
Integer
offset
Integer
count
Boolean
sort
String

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


iscsiPortalIdIdPut

Update iSCSI Portal `id`.


/iscsi/portal/id/{id}

Usage and SDK Samples

curl -X PUT -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/iscsi/portal/id/{id}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.IscsiPortalApi;

import java.io.File;
import java.util.*;

public class IscsiPortalApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        IscsiPortalApi apiInstance = new IscsiPortalApi();
        Integer id = 56; // Integer | 
        Iscsi_portal_update_1 body = ; // Iscsi_portal_update_1 | 
        try {
            apiInstance.iscsiPortalIdIdPut(id, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling IscsiPortalApi#iscsiPortalIdIdPut");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::IscsiPortalApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::IscsiPortalApi->new();
my $id = 56; # Integer | 
my $body = WWW::SwaggerClient::Object::Iscsi_portal_update_1->new(); # Iscsi_portal_update_1 | 

eval { 
    $api_instance->iscsiPortalIdIdPut(id => $id, body => $body);
};
if ($@) {
    warn "Exception when calling IscsiPortalApi->iscsiPortalIdIdPut: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.IscsiPortalApi()
id = 56 # Integer | 
body =  # Iscsi_portal_update_1 |  (optional)

try: 
    api_instance.iscsi_portal_id_id_put(id, body=body)
except ApiException as e:
    print("Exception when calling IscsiPortalApi->iscsiPortalIdIdPut: %s\n" % e)

Parameters

Path parameters
Name Description
id*
Integer
Required
Body parameters
Name Description
body

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


iscsiPortalListenIpChoicesGet

Returns possible choices for `listen.ip` attribute of portal create and update.


/iscsi/portal/listen_ip_choices

Usage and SDK Samples

curl -X GET -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/iscsi/portal/listen_ip_choices"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.IscsiPortalApi;

import java.io.File;
import java.util.*;

public class IscsiPortalApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        IscsiPortalApi apiInstance = new IscsiPortalApi();
        try {
            apiInstance.iscsiPortalListenIpChoicesGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling IscsiPortalApi#iscsiPortalListenIpChoicesGet");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::IscsiPortalApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::IscsiPortalApi->new();

eval { 
    $api_instance->iscsiPortalListenIpChoicesGet();
};
if ($@) {
    warn "Exception when calling IscsiPortalApi->iscsiPortalListenIpChoicesGet: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.IscsiPortalApi()

try: 
    api_instance.iscsi_portal_listen_ip_choices_get()
except ApiException as e:
    print("Exception when calling IscsiPortalApi->iscsiPortalListenIpChoicesGet: %s\n" % e)

Parameters

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


iscsiPortalPost

Create a new iSCSI Portal. `discovery_authgroup` is required for CHAP and CHAP_MUTUAL.


/iscsi/portal

Usage and SDK Samples

curl -X POST -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/iscsi/portal"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.IscsiPortalApi;

import java.io.File;
import java.util.*;

public class IscsiPortalApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        IscsiPortalApi apiInstance = new IscsiPortalApi();
        Iscsi_portal_create_0 body = ; // Iscsi_portal_create_0 | 
        try {
            apiInstance.iscsiPortalPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling IscsiPortalApi#iscsiPortalPost");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::IscsiPortalApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::IscsiPortalApi->new();
my $body = WWW::SwaggerClient::Object::Iscsi_portal_create_0->new(); # Iscsi_portal_create_0 | 

eval { 
    $api_instance->iscsiPortalPost(body => $body);
};
if ($@) {
    warn "Exception when calling IscsiPortalApi->iscsiPortalPost: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.IscsiPortalApi()
body =  # Iscsi_portal_create_0 |  (optional)

try: 
    api_instance.iscsi_portal_post(body=body)
except ApiException as e:
    print("Exception when calling IscsiPortalApi->iscsiPortalPost: %s\n" % e)

Parameters

Body parameters
Name Description
body

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


IscsiTarget

iscsiTargetGet


/iscsi/target

Usage and SDK Samples

curl -X GET -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/iscsi/target?limit=&offset=&count=&sort="
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.IscsiTargetApi;

import java.io.File;
import java.util.*;

public class IscsiTargetApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        IscsiTargetApi apiInstance = new IscsiTargetApi();
        Integer limit = 56; // Integer | 
        Integer offset = 56; // Integer | 
        Boolean count = true; // Boolean | 
        String sort = sort_example; // String | 
        try {
            apiInstance.iscsiTargetGet(limit, offset, count, sort);
        } catch (ApiException e) {
            System.err.println("Exception when calling IscsiTargetApi#iscsiTargetGet");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::IscsiTargetApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::IscsiTargetApi->new();
my $limit = 56; # Integer | 
my $offset = 56; # Integer | 
my $count = true; # Boolean | 
my $sort = sort_example; # String | 

eval { 
    $api_instance->iscsiTargetGet(limit => $limit, offset => $offset, count => $count, sort => $sort);
};
if ($@) {
    warn "Exception when calling IscsiTargetApi->iscsiTargetGet: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.IscsiTargetApi()
limit = 56 # Integer |  (optional)
offset = 56 # Integer |  (optional)
count = true # Boolean |  (optional)
sort = sort_example # String |  (optional)

try: 
    api_instance.iscsi_target_get(limit=limit, offset=offset, count=count, sort=sort)
except ApiException as e:
    print("Exception when calling IscsiTargetApi->iscsiTargetGet: %s\n" % e)

Parameters

Query parameters
Name Description
limit
Integer
offset
Integer
count
Boolean
sort
String

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


iscsiTargetIdIdDelete

Delete iSCSI Target of `id`. Deleting an iSCSI Target makes sure we delete all Associated Targets which use `id` iSCSI Target.


/iscsi/target/id/{id}

Usage and SDK Samples

curl -X DELETE -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/iscsi/target/id/{id}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.IscsiTargetApi;

import java.io.File;
import java.util.*;

public class IscsiTargetApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        IscsiTargetApi apiInstance = new IscsiTargetApi();
        Integer id = 56; // Integer | 
        Boolean body = ; // Boolean | 
        try {
            apiInstance.iscsiTargetIdIdDelete(id, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling IscsiTargetApi#iscsiTargetIdIdDelete");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::IscsiTargetApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::IscsiTargetApi->new();
my $id = 56; # Integer | 
my $body = WWW::SwaggerClient::Object::Boolean->new(); # Boolean | 

eval { 
    $api_instance->iscsiTargetIdIdDelete(id => $id, body => $body);
};
if ($@) {
    warn "Exception when calling IscsiTargetApi->iscsiTargetIdIdDelete: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.IscsiTargetApi()
id = 56 # Integer | 
body =  # Boolean |  (optional)

try: 
    api_instance.iscsi_target_id_id_delete(id, body=body)
except ApiException as e:
    print("Exception when calling IscsiTargetApi->iscsiTargetIdIdDelete: %s\n" % e)

Parameters

Path parameters
Name Description
id*
Integer
Required
Body parameters
Name Description
body

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


iscsiTargetIdIdGet


/iscsi/target/id/{id}

Usage and SDK Samples

curl -X GET -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/iscsi/target/id/{id}?limit=&offset=&count=&sort="
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.IscsiTargetApi;

import java.io.File;
import java.util.*;

public class IscsiTargetApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        IscsiTargetApi apiInstance = new IscsiTargetApi();
        array[null] id = ; // array[null] | 
        Integer limit = 56; // Integer | 
        Integer offset = 56; // Integer | 
        Boolean count = true; // Boolean | 
        String sort = sort_example; // String | 
        try {
            apiInstance.iscsiTargetIdIdGet(id, limit, offset, count, sort);
        } catch (ApiException e) {
            System.err.println("Exception when calling IscsiTargetApi#iscsiTargetIdIdGet");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::IscsiTargetApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::IscsiTargetApi->new();
my $id = []; # array[null] | 
my $limit = 56; # Integer | 
my $offset = 56; # Integer | 
my $count = true; # Boolean | 
my $sort = sort_example; # String | 

eval { 
    $api_instance->iscsiTargetIdIdGet(id => $id, limit => $limit, offset => $offset, count => $count, sort => $sort);
};
if ($@) {
    warn "Exception when calling IscsiTargetApi->iscsiTargetIdIdGet: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.IscsiTargetApi()
id =  # array[null] | 
limit = 56 # Integer |  (optional)
offset = 56 # Integer |  (optional)
count = true # Boolean |  (optional)
sort = sort_example # String |  (optional)

try: 
    api_instance.iscsi_target_id_id_get(id, limit=limit, offset=offset, count=count, sort=sort)
except ApiException as e:
    print("Exception when calling IscsiTargetApi->iscsiTargetIdIdGet: %s\n" % e)

Parameters

Path parameters
Name Description
id*
array[null]
Required
Query parameters
Name Description
limit
Integer
offset
Integer
count
Boolean
sort
String

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


iscsiTargetIdIdPut

Update iSCSI Target of `id`.


/iscsi/target/id/{id}

Usage and SDK Samples

curl -X PUT -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/iscsi/target/id/{id}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.IscsiTargetApi;

import java.io.File;
import java.util.*;

public class IscsiTargetApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        IscsiTargetApi apiInstance = new IscsiTargetApi();
        Integer id = 56; // Integer | 
        Iscsi_target_update_1 body = ; // Iscsi_target_update_1 | 
        try {
            apiInstance.iscsiTargetIdIdPut(id, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling IscsiTargetApi#iscsiTargetIdIdPut");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::IscsiTargetApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::IscsiTargetApi->new();
my $id = 56; # Integer | 
my $body = WWW::SwaggerClient::Object::Iscsi_target_update_1->new(); # Iscsi_target_update_1 | 

eval { 
    $api_instance->iscsiTargetIdIdPut(id => $id, body => $body);
};
if ($@) {
    warn "Exception when calling IscsiTargetApi->iscsiTargetIdIdPut: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.IscsiTargetApi()
id = 56 # Integer | 
body =  # Iscsi_target_update_1 |  (optional)

try: 
    api_instance.iscsi_target_id_id_put(id, body=body)
except ApiException as e:
    print("Exception when calling IscsiTargetApi->iscsiTargetIdIdPut: %s\n" % e)

Parameters

Path parameters
Name Description
id*
Integer
Required
Body parameters
Name Description
body

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


iscsiTargetPost

Create an iSCSI Target. `groups` is a list of group dictionaries which provide information related to using a `portal`, `initiator`, `authmethod` and `auth` with this target. `auth` represents a valid iSCSI Authorized Access and defaults to null.


/iscsi/target

Usage and SDK Samples

curl -X POST -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/iscsi/target"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.IscsiTargetApi;

import java.io.File;
import java.util.*;

public class IscsiTargetApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        IscsiTargetApi apiInstance = new IscsiTargetApi();
        Iscsi_target_create_0 body = ; // Iscsi_target_create_0 | 
        try {
            apiInstance.iscsiTargetPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling IscsiTargetApi#iscsiTargetPost");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::IscsiTargetApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::IscsiTargetApi->new();
my $body = WWW::SwaggerClient::Object::Iscsi_target_create_0->new(); # Iscsi_target_create_0 | 

eval { 
    $api_instance->iscsiTargetPost(body => $body);
};
if ($@) {
    warn "Exception when calling IscsiTargetApi->iscsiTargetPost: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.IscsiTargetApi()
body =  # Iscsi_target_create_0 |  (optional)

try: 
    api_instance.iscsi_target_post(body=body)
except ApiException as e:
    print("Exception when calling IscsiTargetApi->iscsiTargetPost: %s\n" % e)

Parameters

Body parameters
Name Description
body

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


IscsiTargetextent

iscsiTargetextentGet


/iscsi/targetextent

Usage and SDK Samples

curl -X GET -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/iscsi/targetextent?limit=&offset=&count=&sort="
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.IscsiTargetextentApi;

import java.io.File;
import java.util.*;

public class IscsiTargetextentApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        IscsiTargetextentApi apiInstance = new IscsiTargetextentApi();
        Integer limit = 56; // Integer | 
        Integer offset = 56; // Integer | 
        Boolean count = true; // Boolean | 
        String sort = sort_example; // String | 
        try {
            apiInstance.iscsiTargetextentGet(limit, offset, count, sort);
        } catch (ApiException e) {
            System.err.println("Exception when calling IscsiTargetextentApi#iscsiTargetextentGet");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::IscsiTargetextentApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::IscsiTargetextentApi->new();
my $limit = 56; # Integer | 
my $offset = 56; # Integer | 
my $count = true; # Boolean | 
my $sort = sort_example; # String | 

eval { 
    $api_instance->iscsiTargetextentGet(limit => $limit, offset => $offset, count => $count, sort => $sort);
};
if ($@) {
    warn "Exception when calling IscsiTargetextentApi->iscsiTargetextentGet: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.IscsiTargetextentApi()
limit = 56 # Integer |  (optional)
offset = 56 # Integer |  (optional)
count = true # Boolean |  (optional)
sort = sort_example # String |  (optional)

try: 
    api_instance.iscsi_targetextent_get(limit=limit, offset=offset, count=count, sort=sort)
except ApiException as e:
    print("Exception when calling IscsiTargetextentApi->iscsiTargetextentGet: %s\n" % e)

Parameters

Query parameters
Name Description
limit
Integer
offset
Integer
count
Boolean
sort
String

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


iscsiTargetextentIdIdDelete

Delete Associated Target of `id`.


/iscsi/targetextent/id/{id}

Usage and SDK Samples

curl -X DELETE -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/iscsi/targetextent/id/{id}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.IscsiTargetextentApi;

import java.io.File;
import java.util.*;

public class IscsiTargetextentApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        IscsiTargetextentApi apiInstance = new IscsiTargetextentApi();
        Integer id = 56; // Integer | 
        Boolean body = ; // Boolean | 
        try {
            apiInstance.iscsiTargetextentIdIdDelete(id, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling IscsiTargetextentApi#iscsiTargetextentIdIdDelete");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::IscsiTargetextentApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::IscsiTargetextentApi->new();
my $id = 56; # Integer | 
my $body = WWW::SwaggerClient::Object::Boolean->new(); # Boolean | 

eval { 
    $api_instance->iscsiTargetextentIdIdDelete(id => $id, body => $body);
};
if ($@) {
    warn "Exception when calling IscsiTargetextentApi->iscsiTargetextentIdIdDelete: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.IscsiTargetextentApi()
id = 56 # Integer | 
body =  # Boolean |  (optional)

try: 
    api_instance.iscsi_targetextent_id_id_delete(id, body=body)
except ApiException as e:
    print("Exception when calling IscsiTargetextentApi->iscsiTargetextentIdIdDelete: %s\n" % e)

Parameters

Path parameters
Name Description
id*
Integer
Required
Body parameters
Name Description
body

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


iscsiTargetextentIdIdGet


/iscsi/targetextent/id/{id}

Usage and SDK Samples

curl -X GET -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/iscsi/targetextent/id/{id}?limit=&offset=&count=&sort="
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.IscsiTargetextentApi;

import java.io.File;
import java.util.*;

public class IscsiTargetextentApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        IscsiTargetextentApi apiInstance = new IscsiTargetextentApi();
        array[null] id = ; // array[null] | 
        Integer limit = 56; // Integer | 
        Integer offset = 56; // Integer | 
        Boolean count = true; // Boolean | 
        String sort = sort_example; // String | 
        try {
            apiInstance.iscsiTargetextentIdIdGet(id, limit, offset, count, sort);
        } catch (ApiException e) {
            System.err.println("Exception when calling IscsiTargetextentApi#iscsiTargetextentIdIdGet");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::IscsiTargetextentApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::IscsiTargetextentApi->new();
my $id = []; # array[null] | 
my $limit = 56; # Integer | 
my $offset = 56; # Integer | 
my $count = true; # Boolean | 
my $sort = sort_example; # String | 

eval { 
    $api_instance->iscsiTargetextentIdIdGet(id => $id, limit => $limit, offset => $offset, count => $count, sort => $sort);
};
if ($@) {
    warn "Exception when calling IscsiTargetextentApi->iscsiTargetextentIdIdGet: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.IscsiTargetextentApi()
id =  # array[null] | 
limit = 56 # Integer |  (optional)
offset = 56 # Integer |  (optional)
count = true # Boolean |  (optional)
sort = sort_example # String |  (optional)

try: 
    api_instance.iscsi_targetextent_id_id_get(id, limit=limit, offset=offset, count=count, sort=sort)
except ApiException as e:
    print("Exception when calling IscsiTargetextentApi->iscsiTargetextentIdIdGet: %s\n" % e)

Parameters

Path parameters
Name Description
id*
array[null]
Required
Query parameters
Name Description
limit
Integer
offset
Integer
count
Boolean
sort
String

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


iscsiTargetextentIdIdPut

Update Associated Target of `id`.


/iscsi/targetextent/id/{id}

Usage and SDK Samples

curl -X PUT -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/iscsi/targetextent/id/{id}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.IscsiTargetextentApi;

import java.io.File;
import java.util.*;

public class IscsiTargetextentApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        IscsiTargetextentApi apiInstance = new IscsiTargetextentApi();
        Integer id = 56; // Integer | 
        Iscsi_targetextent_update_1 body = ; // Iscsi_targetextent_update_1 | 
        try {
            apiInstance.iscsiTargetextentIdIdPut(id, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling IscsiTargetextentApi#iscsiTargetextentIdIdPut");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::IscsiTargetextentApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::IscsiTargetextentApi->new();
my $id = 56; # Integer | 
my $body = WWW::SwaggerClient::Object::Iscsi_targetextent_update_1->new(); # Iscsi_targetextent_update_1 | 

eval { 
    $api_instance->iscsiTargetextentIdIdPut(id => $id, body => $body);
};
if ($@) {
    warn "Exception when calling IscsiTargetextentApi->iscsiTargetextentIdIdPut: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.IscsiTargetextentApi()
id = 56 # Integer | 
body =  # Iscsi_targetextent_update_1 |  (optional)

try: 
    api_instance.iscsi_targetextent_id_id_put(id, body=body)
except ApiException as e:
    print("Exception when calling IscsiTargetextentApi->iscsiTargetextentIdIdPut: %s\n" % e)

Parameters

Path parameters
Name Description
id*
Integer
Required
Body parameters
Name Description
body

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


iscsiTargetextentPost

Create an Associated Target. `lunid` will be automatically assigned if it is not provided based on the `target`.


/iscsi/targetextent

Usage and SDK Samples

curl -X POST -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/iscsi/targetextent"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.IscsiTargetextentApi;

import java.io.File;
import java.util.*;

public class IscsiTargetextentApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        IscsiTargetextentApi apiInstance = new IscsiTargetextentApi();
        Iscsi_targetextent_create_0 body = ; // Iscsi_targetextent_create_0 | 
        try {
            apiInstance.iscsiTargetextentPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling IscsiTargetextentApi#iscsiTargetextentPost");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::IscsiTargetextentApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::IscsiTargetextentApi->new();
my $body = WWW::SwaggerClient::Object::Iscsi_targetextent_create_0->new(); # Iscsi_targetextent_create_0 | 

eval { 
    $api_instance->iscsiTargetextentPost(body => $body);
};
if ($@) {
    warn "Exception when calling IscsiTargetextentApi->iscsiTargetextentPost: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.IscsiTargetextentApi()
body =  # Iscsi_targetextent_create_0 |  (optional)

try: 
    api_instance.iscsi_targetextent_post(body=body)
except ApiException as e:
    print("Exception when calling IscsiTargetextentApi->iscsiTargetextentPost: %s\n" % e)

Parameters

Body parameters
Name Description
body

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


Jail

jailActivatePost

Activates a pool for iocage usage, and deactivates the rest.


/jail/activate

Usage and SDK Samples

curl -X POST -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/jail/activate"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.JailApi;

import java.io.File;
import java.util.*;

public class JailApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        JailApi apiInstance = new JailApi();
        String body = ; // String | 
        try {
            apiInstance.jailActivatePost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling JailApi#jailActivatePost");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::JailApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::JailApi->new();
my $body = WWW::SwaggerClient::Object::String->new(); # String | 

eval { 
    $api_instance->jailActivatePost(body => $body);
};
if ($@) {
    warn "Exception when calling JailApi->jailActivatePost: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.JailApi()
body =  # String |  (optional)

try: 
    api_instance.jail_activate_post(body=body)
except ApiException as e:
    print("Exception when calling JailApi->jailActivatePost: %s\n" % e)

Parameters

Body parameters
Name Description
body

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


jailCleanPost

Cleans all iocage datasets of ds_type


/jail/clean

Usage and SDK Samples

curl -X POST -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/jail/clean"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.JailApi;

import java.io.File;
import java.util.*;

public class JailApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        JailApi apiInstance = new JailApi();
        String body = ; // String | 
        try {
            apiInstance.jailCleanPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling JailApi#jailCleanPost");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::JailApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::JailApi->new();
my $body = WWW::SwaggerClient::Object::String->new(); # String | 

eval { 
    $api_instance->jailCleanPost(body => $body);
};
if ($@) {
    warn "Exception when calling JailApi->jailCleanPost: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.JailApi()
body =  # String |  (optional)

try: 
    api_instance.jail_clean_post(body=body)
except ApiException as e:
    print("Exception when calling JailApi->jailCleanPost: %s\n" % e)

Parameters

Body parameters
Name Description
body

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


jailDefaultConfigurationGet

Retrieve default configuration for iocage jails.


/jail/default_configuration

Usage and SDK Samples

curl -X GET -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/jail/default_configuration"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.JailApi;

import java.io.File;
import java.util.*;

public class JailApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        JailApi apiInstance = new JailApi();
        try {
            apiInstance.jailDefaultConfigurationGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling JailApi#jailDefaultConfigurationGet");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::JailApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::JailApi->new();

eval { 
    $api_instance->jailDefaultConfigurationGet();
};
if ($@) {
    warn "Exception when calling JailApi->jailDefaultConfigurationGet: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.JailApi()

try: 
    api_instance.jail_default_configuration_get()
except ApiException as e:
    print("Exception when calling JailApi->jailDefaultConfigurationGet: %s\n" % e)

Parameters

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


jailExecPost

Issues a command inside a jail.


/jail/exec

Usage and SDK Samples

curl -X POST -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/jail/exec"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.JailApi;

import java.io.File;
import java.util.*;

public class JailApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        JailApi apiInstance = new JailApi();
        Jail_exec body = ; // Jail_exec | 
        try {
            apiInstance.jailExecPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling JailApi#jailExecPost");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::JailApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::JailApi->new();
my $body = WWW::SwaggerClient::Object::Jail_exec->new(); # Jail_exec | 

eval { 
    $api_instance->jailExecPost(body => $body);
};
if ($@) {
    warn "Exception when calling JailApi->jailExecPost: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.JailApi()
body =  # Jail_exec |  (optional)

try: 
    api_instance.jail_exec_post(body=body)
except ApiException as e:
    print("Exception when calling JailApi->jailExecPost: %s\n" % e)

Parameters

Body parameters
Name Description
body

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


jailExportPost

Export jail to compressed file.


/jail/export

Usage and SDK Samples

curl -X POST -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/jail/export"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.JailApi;

import java.io.File;
import java.util.*;

public class JailApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        JailApi apiInstance = new JailApi();
        Jail_export_0 body = ; // Jail_export_0 | 
        try {
            apiInstance.jailExportPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling JailApi#jailExportPost");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::JailApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::JailApi->new();
my $body = WWW::SwaggerClient::Object::Jail_export_0->new(); # Jail_export_0 | 

eval { 
    $api_instance->jailExportPost(body => $body);
};
if ($@) {
    warn "Exception when calling JailApi->jailExportPost: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.JailApi()
body =  # Jail_export_0 |  (optional)

try: 
    api_instance.jail_export_post(body=body)
except ApiException as e:
    print("Exception when calling JailApi->jailExportPost: %s\n" % e)

Parameters

Body parameters
Name Description
body

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


jailFetchPost

Fetches a release or plugin.


/jail/fetch

Usage and SDK Samples

curl -X POST -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/jail/fetch"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.JailApi;

import java.io.File;
import java.util.*;

public class JailApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        JailApi apiInstance = new JailApi();
        Jail_fetch_0 body = ; // Jail_fetch_0 | 
        try {
            apiInstance.jailFetchPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling JailApi#jailFetchPost");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::JailApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::JailApi->new();
my $body = WWW::SwaggerClient::Object::Jail_fetch_0->new(); # Jail_fetch_0 | 

eval { 
    $api_instance->jailFetchPost(body => $body);
};
if ($@) {
    warn "Exception when calling JailApi->jailFetchPost: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.JailApi()
body =  # Jail_fetch_0 |  (optional)

try: 
    api_instance.jail_fetch_post(body=body)
except ApiException as e:
    print("Exception when calling JailApi->jailFetchPost: %s\n" % e)

Parameters

Body parameters
Name Description
body

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


jailFstabPost

Manipulate a jails fstab


/jail/fstab

Usage and SDK Samples

curl -X POST -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/jail/fstab"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.JailApi;

import java.io.File;
import java.util.*;

public class JailApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        JailApi apiInstance = new JailApi();
        Jail_fstab body = ; // Jail_fstab | 
        try {
            apiInstance.jailFstabPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling JailApi#jailFstabPost");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::JailApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::JailApi->new();
my $body = WWW::SwaggerClient::Object::Jail_fstab->new(); # Jail_fstab | 

eval { 
    $api_instance->jailFstabPost(body => $body);
};
if ($@) {
    warn "Exception when calling JailApi->jailFstabPost: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.JailApi()
body =  # Jail_fstab |  (optional)

try: 
    api_instance.jail_fstab_post(body=body)
except ApiException as e:
    print("Exception when calling JailApi->jailFstabPost: %s\n" % e)

Parameters

Body parameters
Name Description
body

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


jailGet

Query all jails with `query-filters` and `query-options`.


/jail

Usage and SDK Samples

curl -X GET -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/jail?limit=&offset=&count=&sort="
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.JailApi;

import java.io.File;
import java.util.*;

public class JailApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        JailApi apiInstance = new JailApi();
        Integer limit = 56; // Integer | 
        Integer offset = 56; // Integer | 
        Boolean count = true; // Boolean | 
        String sort = sort_example; // String | 
        try {
            apiInstance.jailGet(limit, offset, count, sort);
        } catch (ApiException e) {
            System.err.println("Exception when calling JailApi#jailGet");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::JailApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::JailApi->new();
my $limit = 56; # Integer | 
my $offset = 56; # Integer | 
my $count = true; # Boolean | 
my $sort = sort_example; # String | 

eval { 
    $api_instance->jailGet(limit => $limit, offset => $offset, count => $count, sort => $sort);
};
if ($@) {
    warn "Exception when calling JailApi->jailGet: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.JailApi()
limit = 56 # Integer |  (optional)
offset = 56 # Integer |  (optional)
count = true # Boolean |  (optional)
sort = sort_example # String |  (optional)

try: 
    api_instance.jail_get(limit=limit, offset=offset, count=count, sort=sort)
except ApiException as e:
    print("Exception when calling JailApi->jailGet: %s\n" % e)

Parameters

Query parameters
Name Description
limit
Integer
offset
Integer
count
Boolean
sort
String

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


jailGetActivatedPoolGet

Returns the activated pool if there is one, or None


/jail/get_activated_pool

Usage and SDK Samples

curl -X GET -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/jail/get_activated_pool"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.JailApi;

import java.io.File;
import java.util.*;

public class JailApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        JailApi apiInstance = new JailApi();
        try {
            apiInstance.jailGetActivatedPoolGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling JailApi#jailGetActivatedPoolGet");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::JailApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::JailApi->new();

eval { 
    $api_instance->jailGetActivatedPoolGet();
};
if ($@) {
    warn "Exception when calling JailApi->jailGetActivatedPoolGet: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.JailApi()

try: 
    api_instance.jail_get_activated_pool_get()
except ApiException as e:
    print("Exception when calling JailApi->jailGetActivatedPoolGet: %s\n" % e)

Parameters

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


jailIdIdClonePost


/jail/id/{id}/clone

Usage and SDK Samples

curl -X POST -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/jail/id/{id}/clone"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.JailApi;

import java.io.File;
import java.util.*;

public class JailApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        JailApi apiInstance = new JailApi();
        String id = id_example; // String | 
        Jail_clone_1 body = ; // Jail_clone_1 | 
        try {
            apiInstance.jailIdIdClonePost(id, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling JailApi#jailIdIdClonePost");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::JailApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::JailApi->new();
my $id = id_example; # String | 
my $body = WWW::SwaggerClient::Object::Jail_clone_1->new(); # Jail_clone_1 | 

eval { 
    $api_instance->jailIdIdClonePost(id => $id, body => $body);
};
if ($@) {
    warn "Exception when calling JailApi->jailIdIdClonePost: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.JailApi()
id = id_example # String | 
body =  # Jail_clone_1 |  (optional)

try: 
    api_instance.jail_id_id_clone_post(id, body=body)
except ApiException as e:
    print("Exception when calling JailApi->jailIdIdClonePost: %s\n" % e)

Parameters

Path parameters
Name Description
id*
String
Required
Body parameters
Name Description
body

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


jailIdIdDelete

Takes a jail and destroys it.


/jail/id/{id}

Usage and SDK Samples

curl -X DELETE -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/jail/id/{id}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.JailApi;

import java.io.File;
import java.util.*;

public class JailApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        JailApi apiInstance = new JailApi();
        String id = id_example; // String | 
        Jail_delete_1 body = ; // Jail_delete_1 | 
        try {
            apiInstance.jailIdIdDelete(id, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling JailApi#jailIdIdDelete");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::JailApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::JailApi->new();
my $id = id_example; # String | 
my $body = WWW::SwaggerClient::Object::Jail_delete_1->new(); # Jail_delete_1 | 

eval { 
    $api_instance->jailIdIdDelete(id => $id, body => $body);
};
if ($@) {
    warn "Exception when calling JailApi->jailIdIdDelete: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.JailApi()
id = id_example # String | 
body =  # Jail_delete_1 |  (optional)

try: 
    api_instance.jail_id_id_delete(id, body=body)
except ApiException as e:
    print("Exception when calling JailApi->jailIdIdDelete: %s\n" % e)

Parameters

Path parameters
Name Description
id*
String
Required
Body parameters
Name Description
body

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


jailIdIdGet

Query all jails with `query-filters` and `query-options`.


/jail/id/{id}

Usage and SDK Samples

curl -X GET -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/jail/id/{id}?limit=&offset=&count=&sort="
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.JailApi;

import java.io.File;
import java.util.*;

public class JailApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        JailApi apiInstance = new JailApi();
        array[null] id = ; // array[null] | 
        Integer limit = 56; // Integer | 
        Integer offset = 56; // Integer | 
        Boolean count = true; // Boolean | 
        String sort = sort_example; // String | 
        try {
            apiInstance.jailIdIdGet(id, limit, offset, count, sort);
        } catch (ApiException e) {
            System.err.println("Exception when calling JailApi#jailIdIdGet");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::JailApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::JailApi->new();
my $id = []; # array[null] | 
my $limit = 56; # Integer | 
my $offset = 56; # Integer | 
my $count = true; # Boolean | 
my $sort = sort_example; # String | 

eval { 
    $api_instance->jailIdIdGet(id => $id, limit => $limit, offset => $offset, count => $count, sort => $sort);
};
if ($@) {
    warn "Exception when calling JailApi->jailIdIdGet: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.JailApi()
id =  # array[null] | 
limit = 56 # Integer |  (optional)
offset = 56 # Integer |  (optional)
count = true # Boolean |  (optional)
sort = sort_example # String |  (optional)

try: 
    api_instance.jail_id_id_get(id, limit=limit, offset=offset, count=count, sort=sort)
except ApiException as e:
    print("Exception when calling JailApi->jailIdIdGet: %s\n" % e)

Parameters

Path parameters
Name Description
id*
array[null]
Required
Query parameters
Name Description
limit
Integer
offset
Integer
count
Boolean
sort
String

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


jailIdIdPut

Sets a jail property.


/jail/id/{id}

Usage and SDK Samples

curl -X PUT -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/jail/id/{id}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.JailApi;

import java.io.File;
import java.util.*;

public class JailApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        JailApi apiInstance = new JailApi();
        String id = id_example; // String | 
        map[String, Object] body = ; // map[String, Object] | 
        try {
            apiInstance.jailIdIdPut(id, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling JailApi#jailIdIdPut");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::JailApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::JailApi->new();
my $id = id_example; # String | 
my $body = WWW::SwaggerClient::Object::map[String, Object]->new(); # map[String, Object] | 

eval { 
    $api_instance->jailIdIdPut(id => $id, body => $body);
};
if ($@) {
    warn "Exception when calling JailApi->jailIdIdPut: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.JailApi()
id = id_example # String | 
body =  # map[String, Object] |  (optional)

try: 
    api_instance.jail_id_id_put(id, body=body)
except ApiException as e:
    print("Exception when calling JailApi->jailIdIdPut: %s\n" % e)

Parameters

Path parameters
Name Description
id*
String
Required
Body parameters
Name Description
body

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


jailImportImagePost

Import jail from compressed file. `compression algorithm`: None indicates that middlewared is to automatically determine which compression algorithm to use based on the compressed file extension. If multiple copies are found, an exception is raised. `path` is the directory where the exported jail lives. It defaults to the iocage images dataset.


/jail/import_image

Usage and SDK Samples

curl -X POST -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/jail/import_image"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.JailApi;

import java.io.File;
import java.util.*;

public class JailApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        JailApi apiInstance = new JailApi();
        Jail_import_image_0 body = ; // Jail_import_image_0 | 
        try {
            apiInstance.jailImportImagePost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling JailApi#jailImportImagePost");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::JailApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::JailApi->new();
my $body = WWW::SwaggerClient::Object::Jail_import_image_0->new(); # Jail_import_image_0 | 

eval { 
    $api_instance->jailImportImagePost(body => $body);
};
if ($@) {
    warn "Exception when calling JailApi->jailImportImagePost: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.JailApi()
body =  # Jail_import_image_0 |  (optional)

try: 
    api_instance.jail_import_image_post(body=body)
except ApiException as e:
    print("Exception when calling JailApi->jailImportImagePost: %s\n" % e)

Parameters

Body parameters
Name Description
body

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


jailInterfaceChoicesGet

Returns a dictionary of interface choices which can be used with creating/updating jails.


/jail/interface_choices

Usage and SDK Samples

curl -X GET -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/jail/interface_choices"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.JailApi;

import java.io.File;
import java.util.*;

public class JailApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        JailApi apiInstance = new JailApi();
        try {
            apiInstance.jailInterfaceChoicesGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling JailApi#jailInterfaceChoicesGet");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::JailApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::JailApi->new();

eval { 
    $api_instance->jailInterfaceChoicesGet();
};
if ($@) {
    warn "Exception when calling JailApi->jailInterfaceChoicesGet: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.JailApi()

try: 
    api_instance.jail_interface_choices_get()
except ApiException as e:
    print("Exception when calling JailApi->jailInterfaceChoicesGet: %s\n" % e)

Parameters

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


jailPost

Creates a jail.


/jail

Usage and SDK Samples

curl -X POST -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/jail"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.JailApi;

import java.io.File;
import java.util.*;

public class JailApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        JailApi apiInstance = new JailApi();
        Jail_create_0 body = ; // Jail_create_0 | 
        try {
            apiInstance.jailPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling JailApi#jailPost");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::JailApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::JailApi->new();
my $body = WWW::SwaggerClient::Object::Jail_create_0->new(); # Jail_create_0 | 

eval { 
    $api_instance->jailPost(body => $body);
};
if ($@) {
    warn "Exception when calling JailApi->jailPost: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.JailApi()
body =  # Jail_create_0 |  (optional)

try: 
    api_instance.jail_post(body=body)
except ApiException as e:
    print("Exception when calling JailApi->jailPost: %s\n" % e)

Parameters

Body parameters
Name Description
body

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


jailRcActionPost

Does specified action on rc enabled (boot=on) jails


/jail/rc_action

Usage and SDK Samples

curl -X POST -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/jail/rc_action"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.JailApi;

import java.io.File;
import java.util.*;

public class JailApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        JailApi apiInstance = new JailApi();
        String body = ; // String | 
        try {
            apiInstance.jailRcActionPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling JailApi#jailRcActionPost");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::JailApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::JailApi->new();
my $body = WWW::SwaggerClient::Object::String->new(); # String | 

eval { 
    $api_instance->jailRcActionPost(body => $body);
};
if ($@) {
    warn "Exception when calling JailApi->jailRcActionPost: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.JailApi()
body =  # String |  (optional)

try: 
    api_instance.jail_rc_action_post(body=body)
except ApiException as e:
    print("Exception when calling JailApi->jailRcActionPost: %s\n" % e)

Parameters

Body parameters
Name Description
body

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


jailReleasesChoicesPost

List installed or available releases which can be downloaded.


/jail/releases_choices

Usage and SDK Samples

curl -X POST -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/jail/releases_choices"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.JailApi;

import java.io.File;
import java.util.*;

public class JailApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        JailApi apiInstance = new JailApi();
        Boolean body = ; // Boolean | 
        try {
            apiInstance.jailReleasesChoicesPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling JailApi#jailReleasesChoicesPost");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::JailApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::JailApi->new();
my $body = WWW::SwaggerClient::Object::Boolean->new(); # Boolean | 

eval { 
    $api_instance->jailReleasesChoicesPost(body => $body);
};
if ($@) {
    warn "Exception when calling JailApi->jailReleasesChoicesPost: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.JailApi()
body =  # Boolean |  (optional)

try: 
    api_instance.jail_releases_choices_post(body=body)
except ApiException as e:
    print("Exception when calling JailApi->jailReleasesChoicesPost: %s\n" % e)

Parameters

Body parameters
Name Description
body

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


jailRestartPost

Takes a jail and restarts it.


/jail/restart

Usage and SDK Samples

curl -X POST -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/jail/restart"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.JailApi;

import java.io.File;
import java.util.*;

public class JailApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        JailApi apiInstance = new JailApi();
        String body = ; // String | 
        try {
            apiInstance.jailRestartPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling JailApi#jailRestartPost");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::JailApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::JailApi->new();
my $body = WWW::SwaggerClient::Object::String->new(); # String | 

eval { 
    $api_instance->jailRestartPost(body => $body);
};
if ($@) {
    warn "Exception when calling JailApi->jailRestartPost: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.JailApi()
body =  # String |  (optional)

try: 
    api_instance.jail_restart_post(body=body)
except ApiException as e:
    print("Exception when calling JailApi->jailRestartPost: %s\n" % e)

Parameters

Body parameters
Name Description
body

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


jailStartPost

Takes a jail and starts it.


/jail/start

Usage and SDK Samples

curl -X POST -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/jail/start"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.JailApi;

import java.io.File;
import java.util.*;

public class JailApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        JailApi apiInstance = new JailApi();
        String body = ; // String | 
        try {
            apiInstance.jailStartPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling JailApi#jailStartPost");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::JailApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::JailApi->new();
my $body = WWW::SwaggerClient::Object::String->new(); # String | 

eval { 
    $api_instance->jailStartPost(body => $body);
};
if ($@) {
    warn "Exception when calling JailApi->jailStartPost: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.JailApi()
body =  # String |  (optional)

try: 
    api_instance.jail_start_post(body=body)
except ApiException as e:
    print("Exception when calling JailApi->jailStartPost: %s\n" % e)

Parameters

Body parameters
Name Description
body

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


jailStopPost

Takes a jail and stops it.


/jail/stop

Usage and SDK Samples

curl -X POST -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/jail/stop"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.JailApi;

import java.io.File;
import java.util.*;

public class JailApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        JailApi apiInstance = new JailApi();
        Jail_stop body = ; // Jail_stop | 
        try {
            apiInstance.jailStopPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling JailApi#jailStopPost");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::JailApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::JailApi->new();
my $body = WWW::SwaggerClient::Object::Jail_stop->new(); # Jail_stop | 

eval { 
    $api_instance->jailStopPost(body => $body);
};
if ($@) {
    warn "Exception when calling JailApi->jailStopPost: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.JailApi()
body =  # Jail_stop |  (optional)

try: 
    api_instance.jail_stop_post(body=body)
except ApiException as e:
    print("Exception when calling JailApi->jailStopPost: %s\n" % e)

Parameters

Body parameters
Name Description
body

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


jailUpdateDefaultsPost

Update default properties for iocage which will remain true for all jails moving on i.e nat_backend


/jail/update_defaults

Usage and SDK Samples

curl -X POST -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/jail/update_defaults"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.JailApi;

import java.io.File;
import java.util.*;

public class JailApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        JailApi apiInstance = new JailApi();
        map[String, Object] body = ; // map[String, Object] | 
        try {
            apiInstance.jailUpdateDefaultsPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling JailApi#jailUpdateDefaultsPost");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::JailApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::JailApi->new();
my $body = WWW::SwaggerClient::Object::map[String, Object]->new(); # map[String, Object] | 

eval { 
    $api_instance->jailUpdateDefaultsPost(body => $body);
};
if ($@) {
    warn "Exception when calling JailApi->jailUpdateDefaultsPost: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.JailApi()
body =  # map[String, Object] |  (optional)

try: 
    api_instance.jail_update_defaults_post(body=body)
except ApiException as e:
    print("Exception when calling JailApi->jailUpdateDefaultsPost: %s\n" % e)

Parameters

Body parameters
Name Description
body

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


jailUpdateToLatestPatchPost

Updates specified jail to latest patch level.


/jail/update_to_latest_patch

Usage and SDK Samples

curl -X POST -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/jail/update_to_latest_patch"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.JailApi;

import java.io.File;
import java.util.*;

public class JailApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        JailApi apiInstance = new JailApi();
        Jail_update_to_latest_patch body = ; // Jail_update_to_latest_patch | 
        try {
            apiInstance.jailUpdateToLatestPatchPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling JailApi#jailUpdateToLatestPatchPost");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::JailApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::JailApi->new();
my $body = WWW::SwaggerClient::Object::Jail_update_to_latest_patch->new(); # Jail_update_to_latest_patch | 

eval { 
    $api_instance->jailUpdateToLatestPatchPost(body => $body);
};
if ($@) {
    warn "Exception when calling JailApi->jailUpdateToLatestPatchPost: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.JailApi()
body =  # Jail_update_to_latest_patch |  (optional)

try: 
    api_instance.jail_update_to_latest_patch_post(body=body)
except ApiException as e:
    print("Exception when calling JailApi->jailUpdateToLatestPatchPost: %s\n" % e)

Parameters

Body parameters
Name Description
body

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


Kerberos

kerberosGet


/kerberos

Usage and SDK Samples

curl -X GET -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/kerberos"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.KerberosApi;

import java.io.File;
import java.util.*;

public class KerberosApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        KerberosApi apiInstance = new KerberosApi();
        try {
            apiInstance.kerberosGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling KerberosApi#kerberosGet");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::KerberosApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::KerberosApi->new();

eval { 
    $api_instance->kerberosGet();
};
if ($@) {
    warn "Exception when calling KerberosApi->kerberosGet: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.KerberosApi()

try: 
    api_instance.kerberos_get()
except ApiException as e:
    print("Exception when calling KerberosApi->kerberosGet: %s\n" % e)

Parameters

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


kerberosPut

`appdefaults_aux` add parameters to "appdefaults" section of the krb5.conf file. `libdefaults_aux` add parameters to "libdefaults" section of the krb5.conf file.


/kerberos

Usage and SDK Samples

curl -X PUT -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/kerberos"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.KerberosApi;

import java.io.File;
import java.util.*;

public class KerberosApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        KerberosApi apiInstance = new KerberosApi();
        Kerberos_update_0 body = ; // Kerberos_update_0 | 
        try {
            apiInstance.kerberosPut(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling KerberosApi#kerberosPut");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::KerberosApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::KerberosApi->new();
my $body = WWW::SwaggerClient::Object::Kerberos_update_0->new(); # Kerberos_update_0 | 

eval { 
    $api_instance->kerberosPut(body => $body);
};
if ($@) {
    warn "Exception when calling KerberosApi->kerberosPut: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.KerberosApi()
body =  # Kerberos_update_0 |  (optional)

try: 
    api_instance.kerberos_put(body=body)
except ApiException as e:
    print("Exception when calling KerberosApi->kerberosPut: %s\n" % e)

Parameters

Body parameters
Name Description
body

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


KerberosKeytab

kerberosKeytabGet


/kerberos/keytab

Usage and SDK Samples

curl -X GET -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/kerberos/keytab?limit=&offset=&count=&sort="
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.KerberosKeytabApi;

import java.io.File;
import java.util.*;

public class KerberosKeytabApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        KerberosKeytabApi apiInstance = new KerberosKeytabApi();
        Integer limit = 56; // Integer | 
        Integer offset = 56; // Integer | 
        Boolean count = true; // Boolean | 
        String sort = sort_example; // String | 
        try {
            apiInstance.kerberosKeytabGet(limit, offset, count, sort);
        } catch (ApiException e) {
            System.err.println("Exception when calling KerberosKeytabApi#kerberosKeytabGet");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::KerberosKeytabApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::KerberosKeytabApi->new();
my $limit = 56; # Integer | 
my $offset = 56; # Integer | 
my $count = true; # Boolean | 
my $sort = sort_example; # String | 

eval { 
    $api_instance->kerberosKeytabGet(limit => $limit, offset => $offset, count => $count, sort => $sort);
};
if ($@) {
    warn "Exception when calling KerberosKeytabApi->kerberosKeytabGet: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.KerberosKeytabApi()
limit = 56 # Integer |  (optional)
offset = 56 # Integer |  (optional)
count = true # Boolean |  (optional)
sort = sort_example # String |  (optional)

try: 
    api_instance.kerberos_keytab_get(limit=limit, offset=offset, count=count, sort=sort)
except ApiException as e:
    print("Exception when calling KerberosKeytabApi->kerberosKeytabGet: %s\n" % e)

Parameters

Query parameters
Name Description
limit
Integer
offset
Integer
count
Boolean
sort
String

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


kerberosKeytabIdIdDelete

Delete kerberos keytab by id, and force regeneration of system keytab.


/kerberos/keytab/id/{id}

Usage and SDK Samples

curl -X DELETE -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/kerberos/keytab/id/{id}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.KerberosKeytabApi;

import java.io.File;
import java.util.*;

public class KerberosKeytabApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        KerberosKeytabApi apiInstance = new KerberosKeytabApi();
        Integer id = 56; // Integer | 
        try {
            apiInstance.kerberosKeytabIdIdDelete(id);
        } catch (ApiException e) {
            System.err.println("Exception when calling KerberosKeytabApi#kerberosKeytabIdIdDelete");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::KerberosKeytabApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::KerberosKeytabApi->new();
my $id = 56; # Integer | 

eval { 
    $api_instance->kerberosKeytabIdIdDelete(id => $id);
};
if ($@) {
    warn "Exception when calling KerberosKeytabApi->kerberosKeytabIdIdDelete: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.KerberosKeytabApi()
id = 56 # Integer | 

try: 
    api_instance.kerberos_keytab_id_id_delete(id)
except ApiException as e:
    print("Exception when calling KerberosKeytabApi->kerberosKeytabIdIdDelete: %s\n" % e)

Parameters

Path parameters
Name Description
id*
Integer
Required

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


kerberosKeytabIdIdGet


/kerberos/keytab/id/{id}

Usage and SDK Samples

curl -X GET -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/kerberos/keytab/id/{id}?limit=&offset=&count=&sort="
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.KerberosKeytabApi;

import java.io.File;
import java.util.*;

public class KerberosKeytabApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        KerberosKeytabApi apiInstance = new KerberosKeytabApi();
        array[null] id = ; // array[null] | 
        Integer limit = 56; // Integer | 
        Integer offset = 56; // Integer | 
        Boolean count = true; // Boolean | 
        String sort = sort_example; // String | 
        try {
            apiInstance.kerberosKeytabIdIdGet(id, limit, offset, count, sort);
        } catch (ApiException e) {
            System.err.println("Exception when calling KerberosKeytabApi#kerberosKeytabIdIdGet");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::KerberosKeytabApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::KerberosKeytabApi->new();
my $id = []; # array[null] | 
my $limit = 56; # Integer | 
my $offset = 56; # Integer | 
my $count = true; # Boolean | 
my $sort = sort_example; # String | 

eval { 
    $api_instance->kerberosKeytabIdIdGet(id => $id, limit => $limit, offset => $offset, count => $count, sort => $sort);
};
if ($@) {
    warn "Exception when calling KerberosKeytabApi->kerberosKeytabIdIdGet: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.KerberosKeytabApi()
id =  # array[null] | 
limit = 56 # Integer |  (optional)
offset = 56 # Integer |  (optional)
count = true # Boolean |  (optional)
sort = sort_example # String |  (optional)

try: 
    api_instance.kerberos_keytab_id_id_get(id, limit=limit, offset=offset, count=count, sort=sort)
except ApiException as e:
    print("Exception when calling KerberosKeytabApi->kerberosKeytabIdIdGet: %s\n" % e)

Parameters

Path parameters
Name Description
id*
array[null]
Required
Query parameters
Name Description
limit
Integer
offset
Integer
count
Boolean
sort
String

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


kerberosKeytabIdIdPut

Update kerberos keytab by id.


/kerberos/keytab/id/{id}

Usage and SDK Samples

curl -X PUT -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/kerberos/keytab/id/{id}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.KerberosKeytabApi;

import java.io.File;
import java.util.*;

public class KerberosKeytabApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        KerberosKeytabApi apiInstance = new KerberosKeytabApi();
        Integer id = 56; // Integer | 
        Kerberos_keytab_update_1 body = ; // Kerberos_keytab_update_1 | 
        try {
            apiInstance.kerberosKeytabIdIdPut(id, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling KerberosKeytabApi#kerberosKeytabIdIdPut");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::KerberosKeytabApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::KerberosKeytabApi->new();
my $id = 56; # Integer | 
my $body = WWW::SwaggerClient::Object::Kerberos_keytab_update_1->new(); # Kerberos_keytab_update_1 | 

eval { 
    $api_instance->kerberosKeytabIdIdPut(id => $id, body => $body);
};
if ($@) {
    warn "Exception when calling KerberosKeytabApi->kerberosKeytabIdIdPut: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.KerberosKeytabApi()
id = 56 # Integer | 
body =  # Kerberos_keytab_update_1 |  (optional)

try: 
    api_instance.kerberos_keytab_id_id_put(id, body=body)
except ApiException as e:
    print("Exception when calling KerberosKeytabApi->kerberosKeytabIdIdPut: %s\n" % e)

Parameters

Path parameters
Name Description
id*
Integer
Required
Body parameters
Name Description
body

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


kerberosKeytabPost

Create a kerberos keytab. Uploaded keytab files will be merged with the system keytab under /etc/krb5.keytab. `file` b64encoded kerberos keytab `name` name for kerberos keytab


/kerberos/keytab

Usage and SDK Samples

curl -X POST -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/kerberos/keytab"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.KerberosKeytabApi;

import java.io.File;
import java.util.*;

public class KerberosKeytabApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        KerberosKeytabApi apiInstance = new KerberosKeytabApi();
        Kerberos_keytab_create_0 body = ; // Kerberos_keytab_create_0 | 
        try {
            apiInstance.kerberosKeytabPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling KerberosKeytabApi#kerberosKeytabPost");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::KerberosKeytabApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::KerberosKeytabApi->new();
my $body = WWW::SwaggerClient::Object::Kerberos_keytab_create_0->new(); # Kerberos_keytab_create_0 | 

eval { 
    $api_instance->kerberosKeytabPost(body => $body);
};
if ($@) {
    warn "Exception when calling KerberosKeytabApi->kerberosKeytabPost: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.KerberosKeytabApi()
body =  # Kerberos_keytab_create_0 |  (optional)

try: 
    api_instance.kerberos_keytab_post(body=body)
except ApiException as e:
    print("Exception when calling KerberosKeytabApi->kerberosKeytabPost: %s\n" % e)

Parameters

Body parameters
Name Description
body

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


kerberosKeytabSystemKeytabListGet

Returns content of system keytab (/etc/krb5.keytab).


/kerberos/keytab/system_keytab_list

Usage and SDK Samples

curl -X GET -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/kerberos/keytab/system_keytab_list"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.KerberosKeytabApi;

import java.io.File;
import java.util.*;

public class KerberosKeytabApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        KerberosKeytabApi apiInstance = new KerberosKeytabApi();
        try {
            apiInstance.kerberosKeytabSystemKeytabListGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling KerberosKeytabApi#kerberosKeytabSystemKeytabListGet");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::KerberosKeytabApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::KerberosKeytabApi->new();

eval { 
    $api_instance->kerberosKeytabSystemKeytabListGet();
};
if ($@) {
    warn "Exception when calling KerberosKeytabApi->kerberosKeytabSystemKeytabListGet: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.KerberosKeytabApi()

try: 
    api_instance.kerberos_keytab_system_keytab_list_get()
except ApiException as e:
    print("Exception when calling KerberosKeytabApi->kerberosKeytabSystemKeytabListGet: %s\n" % e)

Parameters

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


KerberosRealm

kerberosRealmGet


/kerberos/realm

Usage and SDK Samples

curl -X GET -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/kerberos/realm?limit=&offset=&count=&sort="
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.KerberosRealmApi;

import java.io.File;
import java.util.*;

public class KerberosRealmApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        KerberosRealmApi apiInstance = new KerberosRealmApi();
        Integer limit = 56; // Integer | 
        Integer offset = 56; // Integer | 
        Boolean count = true; // Boolean | 
        String sort = sort_example; // String | 
        try {
            apiInstance.kerberosRealmGet(limit, offset, count, sort);
        } catch (ApiException e) {
            System.err.println("Exception when calling KerberosRealmApi#kerberosRealmGet");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::KerberosRealmApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::KerberosRealmApi->new();
my $limit = 56; # Integer | 
my $offset = 56; # Integer | 
my $count = true; # Boolean | 
my $sort = sort_example; # String | 

eval { 
    $api_instance->kerberosRealmGet(limit => $limit, offset => $offset, count => $count, sort => $sort);
};
if ($@) {
    warn "Exception when calling KerberosRealmApi->kerberosRealmGet: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.KerberosRealmApi()
limit = 56 # Integer |  (optional)
offset = 56 # Integer |  (optional)
count = true # Boolean |  (optional)
sort = sort_example # String |  (optional)

try: 
    api_instance.kerberos_realm_get(limit=limit, offset=offset, count=count, sort=sort)
except ApiException as e:
    print("Exception when calling KerberosRealmApi->kerberosRealmGet: %s\n" % e)

Parameters

Query parameters
Name Description
limit
Integer
offset
Integer
count
Boolean
sort
String

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


kerberosRealmIdIdDelete

Delete a kerberos realm by ID.


/kerberos/realm/id/{id}

Usage and SDK Samples

curl -X DELETE -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/kerberos/realm/id/{id}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.KerberosRealmApi;

import java.io.File;
import java.util.*;

public class KerberosRealmApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        KerberosRealmApi apiInstance = new KerberosRealmApi();
        Integer id = 56; // Integer | 
        try {
            apiInstance.kerberosRealmIdIdDelete(id);
        } catch (ApiException e) {
            System.err.println("Exception when calling KerberosRealmApi#kerberosRealmIdIdDelete");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::KerberosRealmApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::KerberosRealmApi->new();
my $id = 56; # Integer | 

eval { 
    $api_instance->kerberosRealmIdIdDelete(id => $id);
};
if ($@) {
    warn "Exception when calling KerberosRealmApi->kerberosRealmIdIdDelete: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.KerberosRealmApi()
id = 56 # Integer | 

try: 
    api_instance.kerberos_realm_id_id_delete(id)
except ApiException as e:
    print("Exception when calling KerberosRealmApi->kerberosRealmIdIdDelete: %s\n" % e)

Parameters

Path parameters
Name Description
id*
Integer
Required

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


kerberosRealmIdIdGet


/kerberos/realm/id/{id}

Usage and SDK Samples

curl -X GET -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/kerberos/realm/id/{id}?limit=&offset=&count=&sort="
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.KerberosRealmApi;

import java.io.File;
import java.util.*;

public class KerberosRealmApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        KerberosRealmApi apiInstance = new KerberosRealmApi();
        array[null] id = ; // array[null] | 
        Integer limit = 56; // Integer | 
        Integer offset = 56; // Integer | 
        Boolean count = true; // Boolean | 
        String sort = sort_example; // String | 
        try {
            apiInstance.kerberosRealmIdIdGet(id, limit, offset, count, sort);
        } catch (ApiException e) {
            System.err.println("Exception when calling KerberosRealmApi#kerberosRealmIdIdGet");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::KerberosRealmApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::KerberosRealmApi->new();
my $id = []; # array[null] | 
my $limit = 56; # Integer | 
my $offset = 56; # Integer | 
my $count = true; # Boolean | 
my $sort = sort_example; # String | 

eval { 
    $api_instance->kerberosRealmIdIdGet(id => $id, limit => $limit, offset => $offset, count => $count, sort => $sort);
};
if ($@) {
    warn "Exception when calling KerberosRealmApi->kerberosRealmIdIdGet: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.KerberosRealmApi()
id =  # array[null] | 
limit = 56 # Integer |  (optional)
offset = 56 # Integer |  (optional)
count = true # Boolean |  (optional)
sort = sort_example # String |  (optional)

try: 
    api_instance.kerberos_realm_id_id_get(id, limit=limit, offset=offset, count=count, sort=sort)
except ApiException as e:
    print("Exception when calling KerberosRealmApi->kerberosRealmIdIdGet: %s\n" % e)

Parameters

Path parameters
Name Description
id*
array[null]
Required
Query parameters
Name Description
limit
Integer
offset
Integer
count
Boolean
sort
String

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


kerberosRealmIdIdPut

Update a kerberos realm by id. This will be automatically populated during the domain join process in an Active Directory environment. Kerberos realm names are case-sensitive, but convention is to only use upper-case.


/kerberos/realm/id/{id}

Usage and SDK Samples

curl -X PUT -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/kerberos/realm/id/{id}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.KerberosRealmApi;

import java.io.File;
import java.util.*;

public class KerberosRealmApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        KerberosRealmApi apiInstance = new KerberosRealmApi();
        Integer id = 56; // Integer | 
        Kerberos_realm_update_1 body = ; // Kerberos_realm_update_1 | 
        try {
            apiInstance.kerberosRealmIdIdPut(id, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling KerberosRealmApi#kerberosRealmIdIdPut");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::KerberosRealmApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::KerberosRealmApi->new();
my $id = 56; # Integer | 
my $body = WWW::SwaggerClient::Object::Kerberos_realm_update_1->new(); # Kerberos_realm_update_1 | 

eval { 
    $api_instance->kerberosRealmIdIdPut(id => $id, body => $body);
};
if ($@) {
    warn "Exception when calling KerberosRealmApi->kerberosRealmIdIdPut: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.KerberosRealmApi()
id = 56 # Integer | 
body =  # Kerberos_realm_update_1 |  (optional)

try: 
    api_instance.kerberos_realm_id_id_put(id, body=body)
except ApiException as e:
    print("Exception when calling KerberosRealmApi->kerberosRealmIdIdPut: %s\n" % e)

Parameters

Path parameters
Name Description
id*
Integer
Required
Body parameters
Name Description
body

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


kerberosRealmPost

Create a new kerberos realm. This will be automatically populated during the domain join process in an Active Directory environment. Kerberos realm names are case-sensitive, but convention is to only use upper-case. Entries for kdc, admin_server, and kpasswd_server are not required. If they are unpopulated, then kerberos will use DNS srv records to discover the correct servers. The option to hard-code them is provided due to AD site discovery. Kerberos has no concept of Active Directory sites. This means that middleware performs the site discovery and sets the kerberos configuration based on the AD site.


/kerberos/realm

Usage and SDK Samples

curl -X POST -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/kerberos/realm"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.KerberosRealmApi;

import java.io.File;
import java.util.*;

public class KerberosRealmApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        KerberosRealmApi apiInstance = new KerberosRealmApi();
        Kerberos_realm_create_0 body = ; // Kerberos_realm_create_0 | 
        try {
            apiInstance.kerberosRealmPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling KerberosRealmApi#kerberosRealmPost");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::KerberosRealmApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::KerberosRealmApi->new();
my $body = WWW::SwaggerClient::Object::Kerberos_realm_create_0->new(); # Kerberos_realm_create_0 | 

eval { 
    $api_instance->kerberosRealmPost(body => $body);
};
if ($@) {
    warn "Exception when calling KerberosRealmApi->kerberosRealmPost: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.KerberosRealmApi()
body =  # Kerberos_realm_create_0 |  (optional)

try: 
    api_instance.kerberos_realm_post(body=body)
except ApiException as e:
    print("Exception when calling KerberosRealmApi->kerberosRealmPost: %s\n" % e)

Parameters

Body parameters
Name Description
body

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


Keychaincredential

keychaincredentialGenerateSshKeyPairGet

Generate a public/private key pair Generate a public/private key pair (useful for `SSH_KEY_PAIR` type)


/keychaincredential/generate_ssh_key_pair

Usage and SDK Samples

curl -X GET -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/keychaincredential/generate_ssh_key_pair"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.KeychaincredentialApi;

import java.io.File;
import java.util.*;

public class KeychaincredentialApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        KeychaincredentialApi apiInstance = new KeychaincredentialApi();
        try {
            apiInstance.keychaincredentialGenerateSshKeyPairGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling KeychaincredentialApi#keychaincredentialGenerateSshKeyPairGet");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::KeychaincredentialApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::KeychaincredentialApi->new();

eval { 
    $api_instance->keychaincredentialGenerateSshKeyPairGet();
};
if ($@) {
    warn "Exception when calling KeychaincredentialApi->keychaincredentialGenerateSshKeyPairGet: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.KeychaincredentialApi()

try: 
    api_instance.keychaincredential_generate_ssh_key_pair_get()
except ApiException as e:
    print("Exception when calling KeychaincredentialApi->keychaincredentialGenerateSshKeyPairGet: %s\n" % e)

Parameters

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


keychaincredentialGet


/keychaincredential

Usage and SDK Samples

curl -X GET -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/keychaincredential?limit=&offset=&count=&sort="
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.KeychaincredentialApi;

import java.io.File;
import java.util.*;

public class KeychaincredentialApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        KeychaincredentialApi apiInstance = new KeychaincredentialApi();
        Integer limit = 56; // Integer | 
        Integer offset = 56; // Integer | 
        Boolean count = true; // Boolean | 
        String sort = sort_example; // String | 
        try {
            apiInstance.keychaincredentialGet(limit, offset, count, sort);
        } catch (ApiException e) {
            System.err.println("Exception when calling KeychaincredentialApi#keychaincredentialGet");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::KeychaincredentialApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::KeychaincredentialApi->new();
my $limit = 56; # Integer | 
my $offset = 56; # Integer | 
my $count = true; # Boolean | 
my $sort = sort_example; # String | 

eval { 
    $api_instance->keychaincredentialGet(limit => $limit, offset => $offset, count => $count, sort => $sort);
};
if ($@) {
    warn "Exception when calling KeychaincredentialApi->keychaincredentialGet: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.KeychaincredentialApi()
limit = 56 # Integer |  (optional)
offset = 56 # Integer |  (optional)
count = true # Boolean |  (optional)
sort = sort_example # String |  (optional)

try: 
    api_instance.keychaincredential_get(limit=limit, offset=offset, count=count, sort=sort)
except ApiException as e:
    print("Exception when calling KeychaincredentialApi->keychaincredentialGet: %s\n" % e)

Parameters

Query parameters
Name Description
limit
Integer
offset
Integer
count
Boolean
sort
String

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


keychaincredentialIdIdDelete

Delete Keychain Credential with specific `id`


/keychaincredential/id/{id}

Usage and SDK Samples

curl -X DELETE -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/keychaincredential/id/{id}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.KeychaincredentialApi;

import java.io.File;
import java.util.*;

public class KeychaincredentialApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        KeychaincredentialApi apiInstance = new KeychaincredentialApi();
        Integer id = 56; // Integer | 
        Keychaincredential_delete_1 body = ; // Keychaincredential_delete_1 | 
        try {
            apiInstance.keychaincredentialIdIdDelete(id, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling KeychaincredentialApi#keychaincredentialIdIdDelete");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::KeychaincredentialApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::KeychaincredentialApi->new();
my $id = 56; # Integer | 
my $body = WWW::SwaggerClient::Object::Keychaincredential_delete_1->new(); # Keychaincredential_delete_1 | 

eval { 
    $api_instance->keychaincredentialIdIdDelete(id => $id, body => $body);
};
if ($@) {
    warn "Exception when calling KeychaincredentialApi->keychaincredentialIdIdDelete: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.KeychaincredentialApi()
id = 56 # Integer | 
body =  # Keychaincredential_delete_1 |  (optional)

try: 
    api_instance.keychaincredential_id_id_delete(id, body=body)
except ApiException as e:
    print("Exception when calling KeychaincredentialApi->keychaincredentialIdIdDelete: %s\n" % e)

Parameters

Path parameters
Name Description
id*
Integer
Required
Body parameters
Name Description
body

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


keychaincredentialIdIdGet


/keychaincredential/id/{id}

Usage and SDK Samples

curl -X GET -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/keychaincredential/id/{id}?limit=&offset=&count=&sort="
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.KeychaincredentialApi;

import java.io.File;
import java.util.*;

public class KeychaincredentialApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        KeychaincredentialApi apiInstance = new KeychaincredentialApi();
        array[null] id = ; // array[null] | 
        Integer limit = 56; // Integer | 
        Integer offset = 56; // Integer | 
        Boolean count = true; // Boolean | 
        String sort = sort_example; // String | 
        try {
            apiInstance.keychaincredentialIdIdGet(id, limit, offset, count, sort);
        } catch (ApiException e) {
            System.err.println("Exception when calling KeychaincredentialApi#keychaincredentialIdIdGet");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::KeychaincredentialApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::KeychaincredentialApi->new();
my $id = []; # array[null] | 
my $limit = 56; # Integer | 
my $offset = 56; # Integer | 
my $count = true; # Boolean | 
my $sort = sort_example; # String | 

eval { 
    $api_instance->keychaincredentialIdIdGet(id => $id, limit => $limit, offset => $offset, count => $count, sort => $sort);
};
if ($@) {
    warn "Exception when calling KeychaincredentialApi->keychaincredentialIdIdGet: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.KeychaincredentialApi()
id =  # array[null] | 
limit = 56 # Integer |  (optional)
offset = 56 # Integer |  (optional)
count = true # Boolean |  (optional)
sort = sort_example # String |  (optional)

try: 
    api_instance.keychaincredential_id_id_get(id, limit=limit, offset=offset, count=count, sort=sort)
except ApiException as e:
    print("Exception when calling KeychaincredentialApi->keychaincredentialIdIdGet: %s\n" % e)

Parameters

Path parameters
Name Description
id*
array[null]
Required
Query parameters
Name Description
limit
Integer
offset
Integer
count
Boolean
sort
String

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


keychaincredentialIdIdPut

Update a Keychain Credential with specific `id` Please note that you can't change `type` Also you must specify full `attributes` value See the documentation for `create` method for information on payload contents


/keychaincredential/id/{id}

Usage and SDK Samples

curl -X PUT -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/keychaincredential/id/{id}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.KeychaincredentialApi;

import java.io.File;
import java.util.*;

public class KeychaincredentialApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        KeychaincredentialApi apiInstance = new KeychaincredentialApi();
        Integer id = 56; // Integer | 
        Keychaincredential_update_1 body = ; // Keychaincredential_update_1 | 
        try {
            apiInstance.keychaincredentialIdIdPut(id, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling KeychaincredentialApi#keychaincredentialIdIdPut");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::KeychaincredentialApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::KeychaincredentialApi->new();
my $id = 56; # Integer | 
my $body = WWW::SwaggerClient::Object::Keychaincredential_update_1->new(); # Keychaincredential_update_1 | 

eval { 
    $api_instance->keychaincredentialIdIdPut(id => $id, body => $body);
};
if ($@) {
    warn "Exception when calling KeychaincredentialApi->keychaincredentialIdIdPut: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.KeychaincredentialApi()
id = 56 # Integer | 
body =  # Keychaincredential_update_1 |  (optional)

try: 
    api_instance.keychaincredential_id_id_put(id, body=body)
except ApiException as e:
    print("Exception when calling KeychaincredentialApi->keychaincredentialIdIdPut: %s\n" % e)

Parameters

Path parameters
Name Description
id*
Integer
Required
Body parameters
Name Description
body

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


keychaincredentialPost

Create a Keychain Credential Create a Keychain Credential of any type. Every Keychain Credential has a `name` which is used to distinguish it from others. The following `type`s are supported: * `SSH_KEY_PAIR` Which `attributes` are: * `private_key` * `public_key` (which can be omitted and thus automatically derived from private key) At least one attribute is required. * `SSH_CREDENTIALS` Which `attributes` are: * `host` * `port` (default 22) * `username` (default root) * `private_key` (Keychain Credential ID) * `remote_host_key` (you can use `keychaincredential.remote_ssh_host_key_scan` do discover it) * `cipher`: one of `STANDARD`, `FAST`, or `DISABLED` (last requires special support from both SSH server and client) * `connect_timeout` (default 10)


/keychaincredential

Usage and SDK Samples

curl -X POST -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/keychaincredential"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.KeychaincredentialApi;

import java.io.File;
import java.util.*;

public class KeychaincredentialApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        KeychaincredentialApi apiInstance = new KeychaincredentialApi();
        Keychaincredential_create_0 body = ; // Keychaincredential_create_0 | 
        try {
            apiInstance.keychaincredentialPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling KeychaincredentialApi#keychaincredentialPost");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::KeychaincredentialApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::KeychaincredentialApi->new();
my $body = WWW::SwaggerClient::Object::Keychaincredential_create_0->new(); # Keychaincredential_create_0 | 

eval { 
    $api_instance->keychaincredentialPost(body => $body);
};
if ($@) {
    warn "Exception when calling KeychaincredentialApi->keychaincredentialPost: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.KeychaincredentialApi()
body =  # Keychaincredential_create_0 |  (optional)

try: 
    api_instance.keychaincredential_post(body=body)
except ApiException as e:
    print("Exception when calling KeychaincredentialApi->keychaincredentialPost: %s\n" % e)

Parameters

Body parameters
Name Description
body

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


keychaincredentialRemoteSshHostKeyScanPost

Discover a remote host key Discover a remote host key (useful for `SSH_CREDENTIALS`)


/keychaincredential/remote_ssh_host_key_scan

Usage and SDK Samples

curl -X POST -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/keychaincredential/remote_ssh_host_key_scan"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.KeychaincredentialApi;

import java.io.File;
import java.util.*;

public class KeychaincredentialApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        KeychaincredentialApi apiInstance = new KeychaincredentialApi();
        Keychaincredential_remote_ssh_host_key_scan_0 body = ; // Keychaincredential_remote_ssh_host_key_scan_0 | 
        try {
            apiInstance.keychaincredentialRemoteSshHostKeyScanPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling KeychaincredentialApi#keychaincredentialRemoteSshHostKeyScanPost");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::KeychaincredentialApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::KeychaincredentialApi->new();
my $body = WWW::SwaggerClient::Object::Keychaincredential_remote_ssh_host_key_scan_0->new(); # Keychaincredential_remote_ssh_host_key_scan_0 | 

eval { 
    $api_instance->keychaincredentialRemoteSshHostKeyScanPost(body => $body);
};
if ($@) {
    warn "Exception when calling KeychaincredentialApi->keychaincredentialRemoteSshHostKeyScanPost: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.KeychaincredentialApi()
body =  # Keychaincredential_remote_ssh_host_key_scan_0 |  (optional)

try: 
    api_instance.keychaincredential_remote_ssh_host_key_scan_post(body=body)
except ApiException as e:
    print("Exception when calling KeychaincredentialApi->keychaincredentialRemoteSshHostKeyScanPost: %s\n" % e)

Parameters

Body parameters
Name Description
body

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


keychaincredentialRemoteSshSemiautomaticSetupPost

Perform semi-automatic SSH connection setup with other FreeNAS machine Perform semi-automatic SSH connection setup with other FreeNAS machine. It creates a `SSH_CREDENTIALS` credential with specified `name` that can be used to connect to FreeNAS machine with specified `url` and temporary auth `token`. Other FreeNAS machine adds `private_key` to allowed `username`'s private keys. Other `SSH_CREDENTIALS` attributes such as `cipher` and `connect_timeout` can be specified as well.


/keychaincredential/remote_ssh_semiautomatic_setup

Usage and SDK Samples

curl -X POST -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/keychaincredential/remote_ssh_semiautomatic_setup"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.KeychaincredentialApi;

import java.io.File;
import java.util.*;

public class KeychaincredentialApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        KeychaincredentialApi apiInstance = new KeychaincredentialApi();
        Keychaincredential_remote_ssh_semiautomatic_setup_0 body = ; // Keychaincredential_remote_ssh_semiautomatic_setup_0 | 
        try {
            apiInstance.keychaincredentialRemoteSshSemiautomaticSetupPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling KeychaincredentialApi#keychaincredentialRemoteSshSemiautomaticSetupPost");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::KeychaincredentialApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::KeychaincredentialApi->new();
my $body = WWW::SwaggerClient::Object::Keychaincredential_remote_ssh_semiautomatic_setup_0->new(); # Keychaincredential_remote_ssh_semiautomatic_setup_0 | 

eval { 
    $api_instance->keychaincredentialRemoteSshSemiautomaticSetupPost(body => $body);
};
if ($@) {
    warn "Exception when calling KeychaincredentialApi->keychaincredentialRemoteSshSemiautomaticSetupPost: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.KeychaincredentialApi()
body =  # Keychaincredential_remote_ssh_semiautomatic_setup_0 |  (optional)

try: 
    api_instance.keychaincredential_remote_ssh_semiautomatic_setup_post(body=body)
except ApiException as e:
    print("Exception when calling KeychaincredentialApi->keychaincredentialRemoteSshSemiautomaticSetupPost: %s\n" % e)

Parameters

Body parameters
Name Description
body

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


keychaincredentialUsedByPost

Returns list of objects that use this credential.


/keychaincredential/used_by

Usage and SDK Samples

curl -X POST -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/keychaincredential/used_by"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.KeychaincredentialApi;

import java.io.File;
import java.util.*;

public class KeychaincredentialApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        KeychaincredentialApi apiInstance = new KeychaincredentialApi();
        Integer body = ; // Integer | 
        try {
            apiInstance.keychaincredentialUsedByPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling KeychaincredentialApi#keychaincredentialUsedByPost");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::KeychaincredentialApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::KeychaincredentialApi->new();
my $body = WWW::SwaggerClient::Object::Integer->new(); # Integer | 

eval { 
    $api_instance->keychaincredentialUsedByPost(body => $body);
};
if ($@) {
    warn "Exception when calling KeychaincredentialApi->keychaincredentialUsedByPost: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.KeychaincredentialApi()
body =  # Integer |  (optional)

try: 
    api_instance.keychaincredential_used_by_post(body=body)
except ApiException as e:
    print("Exception when calling KeychaincredentialApi->keychaincredentialUsedByPost: %s\n" % e)

Parameters

Body parameters
Name Description
body

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


Kmip

kmipClearSyncPendingKeysGet

Clear all keys which are pending to be synced between KMIP server and TN database. For ZFS/SED keys, we remove the UID from local database with which we are able to retrieve ZFS/SED keys. It should be used with caution.


/kmip/clear_sync_pending_keys

Usage and SDK Samples

curl -X GET -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/kmip/clear_sync_pending_keys"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.KmipApi;

import java.io.File;
import java.util.*;

public class KmipApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        KmipApi apiInstance = new KmipApi();
        try {
            apiInstance.kmipClearSyncPendingKeysGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling KmipApi#kmipClearSyncPendingKeysGet");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::KmipApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::KmipApi->new();

eval { 
    $api_instance->kmipClearSyncPendingKeysGet();
};
if ($@) {
    warn "Exception when calling KmipApi->kmipClearSyncPendingKeysGet: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.KmipApi()

try: 
    api_instance.kmip_clear_sync_pending_keys_get()
except ApiException as e:
    print("Exception when calling KmipApi->kmipClearSyncPendingKeysGet: %s\n" % e)

Parameters

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


kmipGet


/kmip

Usage and SDK Samples

curl -X GET -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/kmip"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.KmipApi;

import java.io.File;
import java.util.*;

public class KmipApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        KmipApi apiInstance = new KmipApi();
        try {
            apiInstance.kmipGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling KmipApi#kmipGet");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::KmipApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::KmipApi->new();

eval { 
    $api_instance->kmipGet();
};
if ($@) {
    warn "Exception when calling KmipApi->kmipGet: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.KmipApi()

try: 
    api_instance.kmip_get()
except ApiException as e:
    print("Exception when calling KmipApi->kmipGet: %s\n" % e)

Parameters

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


kmipKmipSyncPendingGet

Returns true or false based on if there are keys which are to be synced from local database to remote KMIP server or vice versa.


/kmip/kmip_sync_pending

Usage and SDK Samples

curl -X GET -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/kmip/kmip_sync_pending"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.KmipApi;

import java.io.File;
import java.util.*;

public class KmipApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        KmipApi apiInstance = new KmipApi();
        try {
            apiInstance.kmipKmipSyncPendingGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling KmipApi#kmipKmipSyncPendingGet");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::KmipApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::KmipApi->new();

eval { 
    $api_instance->kmipKmipSyncPendingGet();
};
if ($@) {
    warn "Exception when calling KmipApi->kmipKmipSyncPendingGet: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.KmipApi()

try: 
    api_instance.kmip_kmip_sync_pending_get()
except ApiException as e:
    print("Exception when calling KmipApi->kmipKmipSyncPendingGet: %s\n" % e)

Parameters

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


kmipPut

Update KMIP Server Configuration. System currently authenticates connection with remote KMIP Server with a TLS handshake. `certificate` and `certificate_authority` determine the certs which will be used to initiate the TLS handshake with `server`. `validate` is enabled by default. When enabled, system will test connection to `server` making sure it's reachable. `manage_zfs_keys`/`manage_sed_disks` when enabled will sync keys from local database to remote KMIP server. When disabled, if there are any keys left to be retrieved from the KMIP server, it will sync them back to local database. `enabled` if true, cannot be set to disabled if there are existing keys pending to be synced. However users can still perform this action by enabling `force_clear`. `change_server` is a boolean field which allows users to migrate data between two KMIP servers. System will first migrate keys from old KMIP server to local database and then migrate the keys from local database to new KMIP server. If it is unable to retrieve all the keys from old server, this will fail. Users can bypass this by enabling `force_clear`. `force_clear` is a boolean option which when enabled will in this case remove all pending keys to be synced from database. It should be used with extreme caution as users may end up with not having ZFS dataset or SED disks keys leaving them locked forever. It is disabled by default.


/kmip

Usage and SDK Samples

curl -X PUT -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/kmip"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.KmipApi;

import java.io.File;
import java.util.*;

public class KmipApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        KmipApi apiInstance = new KmipApi();
        Kmip_update_0 body = ; // Kmip_update_0 | 
        try {
            apiInstance.kmipPut(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling KmipApi#kmipPut");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::KmipApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::KmipApi->new();
my $body = WWW::SwaggerClient::Object::Kmip_update_0->new(); # Kmip_update_0 | 

eval { 
    $api_instance->kmipPut(body => $body);
};
if ($@) {
    warn "Exception when calling KmipApi->kmipPut: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.KmipApi()
body =  # Kmip_update_0 |  (optional)

try: 
    api_instance.kmip_put(body=body)
except ApiException as e:
    print("Exception when calling KmipApi->kmipPut: %s\n" % e)

Parameters

Body parameters
Name Description
body

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


kmipSyncKeysGet

Sync ZFS/SED keys between KMIP Server and TN database.


/kmip/sync_keys

Usage and SDK Samples

curl -X GET -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/kmip/sync_keys"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.KmipApi;

import java.io.File;
import java.util.*;

public class KmipApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        KmipApi apiInstance = new KmipApi();
        try {
            apiInstance.kmipSyncKeysGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling KmipApi#kmipSyncKeysGet");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::KmipApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::KmipApi->new();

eval { 
    $api_instance->kmipSyncKeysGet();
};
if ($@) {
    warn "Exception when calling KmipApi->kmipSyncKeysGet: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.KmipApi()

try: 
    api_instance.kmip_sync_keys_get()
except ApiException as e:
    print("Exception when calling KmipApi->kmipSyncKeysGet: %s\n" % e)

Parameters

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


Ldap

ldapGet


/ldap

Usage and SDK Samples

curl -X GET -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/ldap"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.LdapApi;

import java.io.File;
import java.util.*;

public class LdapApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        LdapApi apiInstance = new LdapApi();
        try {
            apiInstance.ldapGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling LdapApi#ldapGet");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::LdapApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::LdapApi->new();

eval { 
    $api_instance->ldapGet();
};
if ($@) {
    warn "Exception when calling LdapApi->ldapGet: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.LdapApi()

try: 
    api_instance.ldap_get()
except ApiException as e:
    print("Exception when calling LdapApi->ldapGet: %s\n" % e)

Parameters

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


ldapGetStateGet

Wrapper function for 'directoryservices.get_state'. Returns only the state of the LDAP service.


/ldap/get_state

Usage and SDK Samples

curl -X GET -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/ldap/get_state"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.LdapApi;

import java.io.File;
import java.util.*;

public class LdapApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        LdapApi apiInstance = new LdapApi();
        try {
            apiInstance.ldapGetStateGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling LdapApi#ldapGetStateGet");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::LdapApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::LdapApi->new();

eval { 
    $api_instance->ldapGetStateGet();
};
if ($@) {
    warn "Exception when calling LdapApi->ldapGetStateGet: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.LdapApi()

try: 
    api_instance.ldap_get_state_get()
except ApiException as e:
    print("Exception when calling LdapApi->ldapGetStateGet: %s\n" % e)

Parameters

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


ldapPut

`hostname` list of ip addresses or hostnames of LDAP servers with which to communicate in order of preference. Failover only occurs if the current LDAP server is unresponsive. `basedn` specifies the default base DN to use when performing ldap operations. The base must be specified as a Distinguished Name in LDAP format. `binddn` specifies the default bind DN to use when performing ldap operations. The bind DN must be specified as a Distinguished Name in LDAP format. `anonbind` use anonymous authentication. `ssl` establish SSL/TLS-protected connections to the LDAP server(s). GSSAPI signing is disabled on SSL/TLS-protected connections if kerberos authentication is used. `certificate` LDAPs client certificate to be used for certificate- based authentication. `validate_certificates` specifies whether to perform checks on server certificates in a TLS session. If enabled, TLS_REQCERT demand is set. The server certificate is requested. If no certificate is provided or if a bad certificate is provided, the session is immediately terminated. If disabled, TLS_REQCERT allow is set. The server certificate is requested, but all errors are ignored. `kerberos_realm` in which the server is located. This parameter is only required for SASL GSSAPI authentication to the remote LDAP server. `kerberos_principal` kerberos principal to use for SASL GSSAPI authentication to the remote server. If `kerberos_realm` is specified without a keytab, then the `binddn` and `bindpw` are used to perform to obtain the ticket necessary for GSSAPI authentication. `timeout` specifies a timeout (in seconds) after which calls to synchronous LDAP APIs will abort if no response is received. `dns_timeout` specifies the timeout (in seconds) after which the poll(2)/select(2) following a connect(2) returns in case of no activity for openldap. For nslcd this specifies the time limit (in seconds) to use when connecting to the directory server. This directly impacts the length of time that the LDAP service tries before failing over to a secondary LDAP URI. `has_samba_schema` determines whether to configure samba to use the ldapsam passdb backend to provide SMB access to LDAP users. This feature requires the presence of Samba LDAP schema extensions on the remote LDAP server.


/ldap

Usage and SDK Samples

curl -X PUT -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/ldap"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.LdapApi;

import java.io.File;
import java.util.*;

public class LdapApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        LdapApi apiInstance = new LdapApi();
        Ldap_update_0 body = ; // Ldap_update_0 | 
        try {
            apiInstance.ldapPut(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling LdapApi#ldapPut");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::LdapApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::LdapApi->new();
my $body = WWW::SwaggerClient::Object::Ldap_update_0->new(); # Ldap_update_0 | 

eval { 
    $api_instance->ldapPut(body => $body);
};
if ($@) {
    warn "Exception when calling LdapApi->ldapPut: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.LdapApi()
body =  # Ldap_update_0 |  (optional)

try: 
    api_instance.ldap_put(body=body)
except ApiException as e:
    print("Exception when calling LdapApi->ldapPut: %s\n" % e)

Parameters

Body parameters
Name Description
body

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


ldapSchemaChoicesGet

Returns list of available LDAP schema choices.


/ldap/schema_choices

Usage and SDK Samples

curl -X GET -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/ldap/schema_choices"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.LdapApi;

import java.io.File;
import java.util.*;

public class LdapApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        LdapApi apiInstance = new LdapApi();
        try {
            apiInstance.ldapSchemaChoicesGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling LdapApi#ldapSchemaChoicesGet");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::LdapApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::LdapApi->new();

eval { 
    $api_instance->ldapSchemaChoicesGet();
};
if ($@) {
    warn "Exception when calling LdapApi->ldapSchemaChoicesGet: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.LdapApi()

try: 
    api_instance.ldap_schema_choices_get()
except ApiException as e:
    print("Exception when calling LdapApi->ldapSchemaChoicesGet: %s\n" % e)

Parameters

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


ldapSslChoicesGet

Returns list of SSL choices.


/ldap/ssl_choices

Usage and SDK Samples

curl -X GET -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/ldap/ssl_choices"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.LdapApi;

import java.io.File;
import java.util.*;

public class LdapApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        LdapApi apiInstance = new LdapApi();
        try {
            apiInstance.ldapSslChoicesGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling LdapApi#ldapSslChoicesGet");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::LdapApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::LdapApi->new();

eval { 
    $api_instance->ldapSslChoicesGet();
};
if ($@) {
    warn "Exception when calling LdapApi->ldapSslChoicesGet: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.LdapApi()

try: 
    api_instance.ldap_ssl_choices_get()
except ApiException as e:
    print("Exception when calling LdapApi->ldapSslChoicesGet: %s\n" % e)

Parameters

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


Lldp

lldpCountryChoicesGet

Returns country choices for LLDP.


/lldp/country_choices

Usage and SDK Samples

curl -X GET -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/lldp/country_choices"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.LldpApi;

import java.io.File;
import java.util.*;

public class LldpApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        LldpApi apiInstance = new LldpApi();
        try {
            apiInstance.lldpCountryChoicesGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling LldpApi#lldpCountryChoicesGet");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::LldpApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::LldpApi->new();

eval { 
    $api_instance->lldpCountryChoicesGet();
};
if ($@) {
    warn "Exception when calling LldpApi->lldpCountryChoicesGet: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.LldpApi()

try: 
    api_instance.lldp_country_choices_get()
except ApiException as e:
    print("Exception when calling LldpApi->lldpCountryChoicesGet: %s\n" % e)

Parameters

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


lldpGet


/lldp

Usage and SDK Samples

curl -X GET -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/lldp"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.LldpApi;

import java.io.File;
import java.util.*;

public class LldpApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        LldpApi apiInstance = new LldpApi();
        try {
            apiInstance.lldpGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling LldpApi#lldpGet");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::LldpApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::LldpApi->new();

eval { 
    $api_instance->lldpGet();
};
if ($@) {
    warn "Exception when calling LldpApi->lldpGet: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.LldpApi()

try: 
    api_instance.lldp_get()
except ApiException as e:
    print("Exception when calling LldpApi->lldpGet: %s\n" % e)

Parameters

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


lldpPut

Update LLDP Service Configuration. `country` is a two letter ISO 3166 country code required for LLDP location support. `location` is an optional attribute specifying the physical location of the host.


/lldp

Usage and SDK Samples

curl -X PUT -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/lldp"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.LldpApi;

import java.io.File;
import java.util.*;

public class LldpApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        LldpApi apiInstance = new LldpApi();
        Lldp_update_0 body = ; // Lldp_update_0 | 
        try {
            apiInstance.lldpPut(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling LldpApi#lldpPut");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::LldpApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::LldpApi->new();
my $body = WWW::SwaggerClient::Object::Lldp_update_0->new(); # Lldp_update_0 | 

eval { 
    $api_instance->lldpPut(body => $body);
};
if ($@) {
    warn "Exception when calling LldpApi->lldpPut: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.LldpApi()
body =  # Lldp_update_0 |  (optional)

try: 
    api_instance.lldp_put(body=body)
except ApiException as e:
    print("Exception when calling LldpApi->lldpPut: %s\n" % e)

Parameters

Body parameters
Name Description
body

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


Mail

mailGet


/mail

Usage and SDK Samples

curl -X GET -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/mail"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.MailApi;

import java.io.File;
import java.util.*;

public class MailApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        MailApi apiInstance = new MailApi();
        try {
            apiInstance.mailGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling MailApi#mailGet");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::MailApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::MailApi->new();

eval { 
    $api_instance->mailGet();
};
if ($@) {
    warn "Exception when calling MailApi->mailGet: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.MailApi()

try: 
    api_instance.mail_get()
except ApiException as e:
    print("Exception when calling MailApi->mailGet: %s\n" % e)

Parameters

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


mailPut

Update Mail Service Configuration. `fromemail` is used as a sending address which the mail server will use for sending emails. `outgoingserver` is the hostname or IP address of SMTP server used for sending an email. `security` is type of encryption desired. `smtp` is a boolean value which when set indicates that SMTP authentication has been enabled and `user`/`pass` are required attributes now.


/mail

Usage and SDK Samples

curl -X PUT -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/mail"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.MailApi;

import java.io.File;
import java.util.*;

public class MailApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        MailApi apiInstance = new MailApi();
        Mail_update_0 body = ; // Mail_update_0 | 
        try {
            apiInstance.mailPut(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling MailApi#mailPut");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::MailApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::MailApi->new();
my $body = WWW::SwaggerClient::Object::Mail_update_0->new(); # Mail_update_0 | 

eval { 
    $api_instance->mailPut(body => $body);
};
if ($@) {
    warn "Exception when calling MailApi->mailPut: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.MailApi()
body =  # Mail_update_0 |  (optional)

try: 
    api_instance.mail_put(body=body)
except ApiException as e:
    print("Exception when calling MailApi->mailPut: %s\n" % e)

Parameters

Body parameters
Name Description
body

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


mailSendPost

Sends mail using configured mail settings. `text` will be formatted to HTML using Markdown and rendered using default E-Mail template. You can put your own HTML using `html`. If `html` is null, no HTML MIME part will be added to E-Mail. If `attachments` is true, a list compromised of the following dict is required via HTTP upload: - headers(list) - name(str) - value(str) - params(dict) - content (str) [ { "headers": [ { "name": "Content-Transfer-Encoding", "value": "base64" }, { "name": "Content-Type", "value": "application/octet-stream", "params": { "name": "test.txt" } } ], "content": "dGVzdAo=" } ] A file can be uploaded to this end point. This end point is special, please refer to Jobs section in Websocket API documentation for details.


/mail/send

Usage and SDK Samples

curl -X POST -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/mail/send"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.MailApi;

import java.io.File;
import java.util.*;

public class MailApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        MailApi apiInstance = new MailApi();
        Mail_send body = ; // Mail_send | 
        try {
            apiInstance.mailSendPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling MailApi#mailSendPost");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::MailApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::MailApi->new();
my $body = WWW::SwaggerClient::Object::Mail_send->new(); # Mail_send | 

eval { 
    $api_instance->mailSendPost(body => $body);
};
if ($@) {
    warn "Exception when calling MailApi->mailSendPost: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.MailApi()
body =  # Mail_send |  (optional)

try: 
    api_instance.mail_send_post(body=body)
except ApiException as e:
    print("Exception when calling MailApi->mailSendPost: %s\n" % e)

Parameters

Body parameters
Name Description
body

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


Multipath

multipathGet

Get multipaths and their consumers.


/multipath

Usage and SDK Samples

curl -X GET -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/multipath?limit=&offset=&count=&sort="
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.MultipathApi;

import java.io.File;
import java.util.*;

public class MultipathApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        MultipathApi apiInstance = new MultipathApi();
        Integer limit = 56; // Integer | 
        Integer offset = 56; // Integer | 
        Boolean count = true; // Boolean | 
        String sort = sort_example; // String | 
        try {
            apiInstance.multipathGet(limit, offset, count, sort);
        } catch (ApiException e) {
            System.err.println("Exception when calling MultipathApi#multipathGet");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::MultipathApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::MultipathApi->new();
my $limit = 56; # Integer | 
my $offset = 56; # Integer | 
my $count = true; # Boolean | 
my $sort = sort_example; # String | 

eval { 
    $api_instance->multipathGet(limit => $limit, offset => $offset, count => $count, sort => $sort);
};
if ($@) {
    warn "Exception when calling MultipathApi->multipathGet: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.MultipathApi()
limit = 56 # Integer |  (optional)
offset = 56 # Integer |  (optional)
count = true # Boolean |  (optional)
sort = sort_example # String |  (optional)

try: 
    api_instance.multipath_get(limit=limit, offset=offset, count=count, sort=sort)
except ApiException as e:
    print("Exception when calling MultipathApi->multipathGet: %s\n" % e)

Parameters

Query parameters
Name Description
limit
Integer
offset
Integer
count
Boolean
sort
String

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


multipathIdIdGet

Get multipaths and their consumers.


/multipath/id/{id}

Usage and SDK Samples

curl -X GET -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/multipath/id/{id}?limit=&offset=&count=&sort="
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.MultipathApi;

import java.io.File;
import java.util.*;

public class MultipathApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        MultipathApi apiInstance = new MultipathApi();
        array[null] id = ; // array[null] | 
        Integer limit = 56; // Integer | 
        Integer offset = 56; // Integer | 
        Boolean count = true; // Boolean | 
        String sort = sort_example; // String | 
        try {
            apiInstance.multipathIdIdGet(id, limit, offset, count, sort);
        } catch (ApiException e) {
            System.err.println("Exception when calling MultipathApi#multipathIdIdGet");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::MultipathApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::MultipathApi->new();
my $id = []; # array[null] | 
my $limit = 56; # Integer | 
my $offset = 56; # Integer | 
my $count = true; # Boolean | 
my $sort = sort_example; # String | 

eval { 
    $api_instance->multipathIdIdGet(id => $id, limit => $limit, offset => $offset, count => $count, sort => $sort);
};
if ($@) {
    warn "Exception when calling MultipathApi->multipathIdIdGet: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.MultipathApi()
id =  # array[null] | 
limit = 56 # Integer |  (optional)
offset = 56 # Integer |  (optional)
count = true # Boolean |  (optional)
sort = sort_example # String |  (optional)

try: 
    api_instance.multipath_id_id_get(id, limit=limit, offset=offset, count=count, sort=sort)
except ApiException as e:
    print("Exception when calling MultipathApi->multipathIdIdGet: %s\n" % e)

Parameters

Path parameters
Name Description
id*
array[null]
Required
Query parameters
Name Description
limit
Integer
offset
Integer
count
Boolean
sort
String

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


NetworkConfiguration

networkConfigurationGet


/network/configuration

Usage and SDK Samples

curl -X GET -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/network/configuration"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.NetworkConfigurationApi;

import java.io.File;
import java.util.*;

public class NetworkConfigurationApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        NetworkConfigurationApi apiInstance = new NetworkConfigurationApi();
        try {
            apiInstance.networkConfigurationGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling NetworkConfigurationApi#networkConfigurationGet");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::NetworkConfigurationApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::NetworkConfigurationApi->new();

eval { 
    $api_instance->networkConfigurationGet();
};
if ($@) {
    warn "Exception when calling NetworkConfigurationApi->networkConfigurationGet: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.NetworkConfigurationApi()

try: 
    api_instance.network_configuration_get()
except ApiException as e:
    print("Exception when calling NetworkConfigurationApi->networkConfigurationGet: %s\n" % e)

Parameters

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


networkConfigurationPut

Update Network Configuration Service configuration. `ipv4gateway` if set is used instead of the default gateway provided by DHCP. `nameserver1` is primary DNS server. `nameserver2` is secondary DNS server. `nameserver3` is tertiary DNS server. `httpproxy` attribute must be provided if a proxy is to be used for network operations. `netwait_enabled` is a boolean attribute which when set indicates that network services will not start at boot unless they are able to ping the addresses listed in `netwait_ip` list. `service_announcement` determines the broadcast protocols that will be used to advertise the server. `netbios` enables the NetBIOS name server (NBNS), which starts concurrently with the SMB service. SMB clients will only perform NBNS lookups if SMB1 is enabled. NBNS may be required for legacy SMB clients. `mdns` enables multicast DNS service announcements for enabled services. `wsd` enables Web Service Discovery support.


/network/configuration

Usage and SDK Samples

curl -X PUT -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/network/configuration"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.NetworkConfigurationApi;

import java.io.File;
import java.util.*;

public class NetworkConfigurationApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        NetworkConfigurationApi apiInstance = new NetworkConfigurationApi();
        Network_configuration_update_0 body = ; // Network_configuration_update_0 | 
        try {
            apiInstance.networkConfigurationPut(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling NetworkConfigurationApi#networkConfigurationPut");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::NetworkConfigurationApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::NetworkConfigurationApi->new();
my $body = WWW::SwaggerClient::Object::Network_configuration_update_0->new(); # Network_configuration_update_0 | 

eval { 
    $api_instance->networkConfigurationPut(body => $body);
};
if ($@) {
    warn "Exception when calling NetworkConfigurationApi->networkConfigurationPut: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.NetworkConfigurationApi()
body =  # Network_configuration_update_0 |  (optional)

try: 
    api_instance.network_configuration_put(body=body)
except ApiException as e:
    print("Exception when calling NetworkConfigurationApi->networkConfigurationPut: %s\n" % e)

Parameters

Body parameters
Name Description
body

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


NetworkGeneral

networkGeneralSummaryGet

Retrieve general information for current Network. Returns a dictionary. For example:


/network/general/summary

Usage and SDK Samples

curl -X GET -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/network/general/summary"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.NetworkGeneralApi;

import java.io.File;
import java.util.*;

public class NetworkGeneralApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        NetworkGeneralApi apiInstance = new NetworkGeneralApi();
        try {
            apiInstance.networkGeneralSummaryGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling NetworkGeneralApi#networkGeneralSummaryGet");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::NetworkGeneralApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::NetworkGeneralApi->new();

eval { 
    $api_instance->networkGeneralSummaryGet();
};
if ($@) {
    warn "Exception when calling NetworkGeneralApi->networkGeneralSummaryGet: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.NetworkGeneralApi()

try: 
    api_instance.network_general_summary_get()
except ApiException as e:
    print("Exception when calling NetworkGeneralApi->networkGeneralSummaryGet: %s\n" % e)

Parameters

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


Nfs

nfsBindipChoicesGet

Returns ip choices for NFS service to use


/nfs/bindip_choices

Usage and SDK Samples

curl -X GET -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/nfs/bindip_choices"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.NfsApi;

import java.io.File;
import java.util.*;

public class NfsApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        NfsApi apiInstance = new NfsApi();
        try {
            apiInstance.nfsBindipChoicesGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling NfsApi#nfsBindipChoicesGet");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::NfsApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::NfsApi->new();

eval { 
    $api_instance->nfsBindipChoicesGet();
};
if ($@) {
    warn "Exception when calling NfsApi->nfsBindipChoicesGet: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.NfsApi()

try: 
    api_instance.nfs_bindip_choices_get()
except ApiException as e:
    print("Exception when calling NfsApi->nfsBindipChoicesGet: %s\n" % e)

Parameters

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


nfsGet


/nfs

Usage and SDK Samples

curl -X GET -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/nfs"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.NfsApi;

import java.io.File;
import java.util.*;

public class NfsApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        NfsApi apiInstance = new NfsApi();
        try {
            apiInstance.nfsGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling NfsApi#nfsGet");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::NfsApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::NfsApi->new();

eval { 
    $api_instance->nfsGet();
};
if ($@) {
    warn "Exception when calling NfsApi->nfsGet: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.NfsApi()

try: 
    api_instance.nfs_get()
except ApiException as e:
    print("Exception when calling NfsApi->nfsGet: %s\n" % e)

Parameters

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


nfsPut

Update NFS Service Configuration. `servers` represents number of servers to create. When `allow_nonroot` is set, it allows non-root mount requests to be served. `bindip` is a list of IP's on which NFS will listen for requests. When it is unset/empty, NFS listens on all available addresses. `v4` when set means that we switch from NFSv3 to NFSv4. `v4_v3owner` when set means that system will use NFSv3 ownership model for NFSv4. `v4_krb` will force NFS shares to fail if the Kerberos ticket is unavailable. `v4_domain` overrides the default DNS domain name for NFSv4. `mountd_port` specifies the port mountd(8) binds to. `rpcstatd_port` specifies the port rpc.statd(8) binds to. `rpclockd_port` specifies the port rpclockd_port(8) binds to.


/nfs

Usage and SDK Samples

curl -X PUT -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/nfs"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.NfsApi;

import java.io.File;
import java.util.*;

public class NfsApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        NfsApi apiInstance = new NfsApi();
        Nfs_update_0 body = ; // Nfs_update_0 | 
        try {
            apiInstance.nfsPut(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling NfsApi#nfsPut");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::NfsApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::NfsApi->new();
my $body = WWW::SwaggerClient::Object::Nfs_update_0->new(); # Nfs_update_0 | 

eval { 
    $api_instance->nfsPut(body => $body);
};
if ($@) {
    warn "Exception when calling NfsApi->nfsPut: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.NfsApi()
body =  # Nfs_update_0 |  (optional)

try: 
    api_instance.nfs_put(body=body)
except ApiException as e:
    print("Exception when calling NfsApi->nfsPut: %s\n" % e)

Parameters

Body parameters
Name Description
body

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


Nis

nisGet


/nis

Usage and SDK Samples

curl -X GET -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/nis"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.NisApi;

import java.io.File;
import java.util.*;

public class NisApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        NisApi apiInstance = new NisApi();
        try {
            apiInstance.nisGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling NisApi#nisGet");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::NisApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::NisApi->new();

eval { 
    $api_instance->nisGet();
};
if ($@) {
    warn "Exception when calling NisApi->nisGet: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.NisApi()

try: 
    api_instance.nis_get()
except ApiException as e:
    print("Exception when calling NisApi->nisGet: %s\n" % e)

Parameters

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


nisGetStateGet

Wrapper function for 'directoryservices.get_state'. Returns only the state of the NIS service.


/nis/get_state

Usage and SDK Samples

curl -X GET -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/nis/get_state"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.NisApi;

import java.io.File;
import java.util.*;

public class NisApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        NisApi apiInstance = new NisApi();
        try {
            apiInstance.nisGetStateGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling NisApi#nisGetStateGet");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::NisApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::NisApi->new();

eval { 
    $api_instance->nisGetStateGet();
};
if ($@) {
    warn "Exception when calling NisApi->nisGetStateGet: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.NisApi()

try: 
    api_instance.nis_get_state_get()
except ApiException as e:
    print("Exception when calling NisApi->nisGetStateGet: %s\n" % e)

Parameters

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


nisPut

Update NIS Service Configuration. `domain` is the name of NIS domain. `servers` is a list of hostnames/IP addresses. `secure_mode` when enabled sets ypbind(8) to refuse binding to any NIS server not running as root on a TCP port over 1024. `manycast` when enabled sets ypbind(8) to bind to the server that responds the fastest. `enable` enables and starts the NIS service. The NIS service is disabled when this value is changed to False.


/nis

Usage and SDK Samples

curl -X PUT -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/nis"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.NisApi;

import java.io.File;
import java.util.*;

public class NisApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        NisApi apiInstance = new NisApi();
        Nis_update_0 body = ; // Nis_update_0 | 
        try {
            apiInstance.nisPut(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling NisApi#nisPut");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::NisApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::NisApi->new();
my $body = WWW::SwaggerClient::Object::Nis_update_0->new(); # Nis_update_0 | 

eval { 
    $api_instance->nisPut(body => $body);
};
if ($@) {
    warn "Exception when calling NisApi->nisPut: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.NisApi()
body =  # Nis_update_0 |  (optional)

try: 
    api_instance.nis_put(body=body)
except ApiException as e:
    print("Exception when calling NisApi->nisPut: %s\n" % e)

Parameters

Body parameters
Name Description
body

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


OpenvpnClient

openvpnClientAuthenticationAlgorithmChoicesGet

Returns a dictionary of valid authentication algorithms which can be used with OpenVPN server.


/openvpn/client/authentication_algorithm_choices

Usage and SDK Samples

curl -X GET -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/openvpn/client/authentication_algorithm_choices"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.OpenvpnClientApi;

import java.io.File;
import java.util.*;

public class OpenvpnClientApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        OpenvpnClientApi apiInstance = new OpenvpnClientApi();
        try {
            apiInstance.openvpnClientAuthenticationAlgorithmChoicesGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling OpenvpnClientApi#openvpnClientAuthenticationAlgorithmChoicesGet");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::OpenvpnClientApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::OpenvpnClientApi->new();

eval { 
    $api_instance->openvpnClientAuthenticationAlgorithmChoicesGet();
};
if ($@) {
    warn "Exception when calling OpenvpnClientApi->openvpnClientAuthenticationAlgorithmChoicesGet: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.OpenvpnClientApi()

try: 
    api_instance.openvpn_client_authentication_algorithm_choices_get()
except ApiException as e:
    print("Exception when calling OpenvpnClientApi->openvpnClientAuthenticationAlgorithmChoicesGet: %s\n" % e)

Parameters

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


openvpnClientCipherChoicesGet

Returns a dictionary of valid ciphers which can be used with OpenVPN server.


/openvpn/client/cipher_choices

Usage and SDK Samples

curl -X GET -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/openvpn/client/cipher_choices"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.OpenvpnClientApi;

import java.io.File;
import java.util.*;

public class OpenvpnClientApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        OpenvpnClientApi apiInstance = new OpenvpnClientApi();
        try {
            apiInstance.openvpnClientCipherChoicesGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling OpenvpnClientApi#openvpnClientCipherChoicesGet");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::OpenvpnClientApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::OpenvpnClientApi->new();

eval { 
    $api_instance->openvpnClientCipherChoicesGet();
};
if ($@) {
    warn "Exception when calling OpenvpnClientApi->openvpnClientCipherChoicesGet: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.OpenvpnClientApi()

try: 
    api_instance.openvpn_client_cipher_choices_get()
except ApiException as e:
    print("Exception when calling OpenvpnClientApi->openvpnClientCipherChoicesGet: %s\n" % e)

Parameters

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


openvpnClientGet


/openvpn/client

Usage and SDK Samples

curl -X GET -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/openvpn/client"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.OpenvpnClientApi;

import java.io.File;
import java.util.*;

public class OpenvpnClientApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        OpenvpnClientApi apiInstance = new OpenvpnClientApi();
        try {
            apiInstance.openvpnClientGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling OpenvpnClientApi#openvpnClientGet");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::OpenvpnClientApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::OpenvpnClientApi->new();

eval { 
    $api_instance->openvpnClientGet();
};
if ($@) {
    warn "Exception when calling OpenvpnClientApi->openvpnClientGet: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.OpenvpnClientApi()

try: 
    api_instance.openvpn_client_get()
except ApiException as e:
    print("Exception when calling OpenvpnClientApi->openvpnClientGet: %s\n" % e)

Parameters

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


openvpnClientPut

Update OpenVPN Client configuration. `remote` can be a valid ip address / domain which openvpn will try to connect to. `nobind` must be enabled if OpenVPN client / server are to run concurrently.


/openvpn/client

Usage and SDK Samples

curl -X PUT -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/openvpn/client"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.OpenvpnClientApi;

import java.io.File;
import java.util.*;

public class OpenvpnClientApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        OpenvpnClientApi apiInstance = new OpenvpnClientApi();
        Openvpn_client_update_0 body = ; // Openvpn_client_update_0 | 
        try {
            apiInstance.openvpnClientPut(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling OpenvpnClientApi#openvpnClientPut");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::OpenvpnClientApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::OpenvpnClientApi->new();
my $body = WWW::SwaggerClient::Object::Openvpn_client_update_0->new(); # Openvpn_client_update_0 | 

eval { 
    $api_instance->openvpnClientPut(body => $body);
};
if ($@) {
    warn "Exception when calling OpenvpnClientApi->openvpnClientPut: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.OpenvpnClientApi()
body =  # Openvpn_client_update_0 |  (optional)

try: 
    api_instance.openvpn_client_put(body=body)
except ApiException as e:
    print("Exception when calling OpenvpnClientApi->openvpnClientPut: %s\n" % e)

Parameters

Body parameters
Name Description
body

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


OpenvpnServer

openvpnServerAuthenticationAlgorithmChoicesGet

Returns a dictionary of valid authentication algorithms which can be used with OpenVPN server.


/openvpn/server/authentication_algorithm_choices

Usage and SDK Samples

curl -X GET -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/openvpn/server/authentication_algorithm_choices"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.OpenvpnServerApi;

import java.io.File;
import java.util.*;

public class OpenvpnServerApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        OpenvpnServerApi apiInstance = new OpenvpnServerApi();
        try {
            apiInstance.openvpnServerAuthenticationAlgorithmChoicesGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling OpenvpnServerApi#openvpnServerAuthenticationAlgorithmChoicesGet");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::OpenvpnServerApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::OpenvpnServerApi->new();

eval { 
    $api_instance->openvpnServerAuthenticationAlgorithmChoicesGet();
};
if ($@) {
    warn "Exception when calling OpenvpnServerApi->openvpnServerAuthenticationAlgorithmChoicesGet: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.OpenvpnServerApi()

try: 
    api_instance.openvpn_server_authentication_algorithm_choices_get()
except ApiException as e:
    print("Exception when calling OpenvpnServerApi->openvpnServerAuthenticationAlgorithmChoicesGet: %s\n" % e)

Parameters

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


openvpnServerCipherChoicesGet

Returns a dictionary of valid ciphers which can be used with OpenVPN server.


/openvpn/server/cipher_choices

Usage and SDK Samples

curl -X GET -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/openvpn/server/cipher_choices"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.OpenvpnServerApi;

import java.io.File;
import java.util.*;

public class OpenvpnServerApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        OpenvpnServerApi apiInstance = new OpenvpnServerApi();
        try {
            apiInstance.openvpnServerCipherChoicesGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling OpenvpnServerApi#openvpnServerCipherChoicesGet");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::OpenvpnServerApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::OpenvpnServerApi->new();

eval { 
    $api_instance->openvpnServerCipherChoicesGet();
};
if ($@) {
    warn "Exception when calling OpenvpnServerApi->openvpnServerCipherChoicesGet: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.OpenvpnServerApi()

try: 
    api_instance.openvpn_server_cipher_choices_get()
except ApiException as e:
    print("Exception when calling OpenvpnServerApi->openvpnServerCipherChoicesGet: %s\n" % e)

Parameters

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


openvpnServerClientConfigurationGenerationPost

Returns a configuration for OpenVPN client which can be used with any client to connect to FN/TN OpenVPN server. `client_certificate_id` should be a valid certificate issued for use with OpenVPN client service. `server_address` if specified auto-fills the remote directive in the OpenVPN configuration enabling the end user to use the file without making any edits to connect to OpenVPN server.


/openvpn/server/client_configuration_generation

Usage and SDK Samples

curl -X POST -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/openvpn/server/client_configuration_generation"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.OpenvpnServerApi;

import java.io.File;
import java.util.*;

public class OpenvpnServerApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        OpenvpnServerApi apiInstance = new OpenvpnServerApi();
        Openvpn_server_client_configuration_generation body = ; // Openvpn_server_client_configuration_generation | 
        try {
            apiInstance.openvpnServerClientConfigurationGenerationPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling OpenvpnServerApi#openvpnServerClientConfigurationGenerationPost");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::OpenvpnServerApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::OpenvpnServerApi->new();
my $body = WWW::SwaggerClient::Object::Openvpn_server_client_configuration_generation->new(); # Openvpn_server_client_configuration_generation | 

eval { 
    $api_instance->openvpnServerClientConfigurationGenerationPost(body => $body);
};
if ($@) {
    warn "Exception when calling OpenvpnServerApi->openvpnServerClientConfigurationGenerationPost: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.OpenvpnServerApi()
body =  # Openvpn_server_client_configuration_generation |  (optional)

try: 
    api_instance.openvpn_server_client_configuration_generation_post(body=body)
except ApiException as e:
    print("Exception when calling OpenvpnServerApi->openvpnServerClientConfigurationGenerationPost: %s\n" % e)

Parameters

Body parameters
Name Description
body

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


openvpnServerGet


/openvpn/server

Usage and SDK Samples

curl -X GET -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/openvpn/server"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.OpenvpnServerApi;

import java.io.File;
import java.util.*;

public class OpenvpnServerApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        OpenvpnServerApi apiInstance = new OpenvpnServerApi();
        try {
            apiInstance.openvpnServerGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling OpenvpnServerApi#openvpnServerGet");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::OpenvpnServerApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::OpenvpnServerApi->new();

eval { 
    $api_instance->openvpnServerGet();
};
if ($@) {
    warn "Exception when calling OpenvpnServerApi->openvpnServerGet: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.OpenvpnServerApi()

try: 
    api_instance.openvpn_server_get()
except ApiException as e:
    print("Exception when calling OpenvpnServerApi->openvpnServerGet: %s\n" % e)

Parameters

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


openvpnServerPut

Update OpenVPN Server configuration. When `tls_crypt_auth_enabled` is enabled and `tls_crypt_auth` not provided, a static key is automatically generated to be used with OpenVPN server.


/openvpn/server

Usage and SDK Samples

curl -X PUT -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/openvpn/server"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.OpenvpnServerApi;

import java.io.File;
import java.util.*;

public class OpenvpnServerApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        OpenvpnServerApi apiInstance = new OpenvpnServerApi();
        Openvpn_server_update_0 body = ; // Openvpn_server_update_0 | 
        try {
            apiInstance.openvpnServerPut(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling OpenvpnServerApi#openvpnServerPut");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::OpenvpnServerApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::OpenvpnServerApi->new();
my $body = WWW::SwaggerClient::Object::Openvpn_server_update_0->new(); # Openvpn_server_update_0 | 

eval { 
    $api_instance->openvpnServerPut(body => $body);
};
if ($@) {
    warn "Exception when calling OpenvpnServerApi->openvpnServerPut: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.OpenvpnServerApi()
body =  # Openvpn_server_update_0 |  (optional)

try: 
    api_instance.openvpn_server_put(body=body)
except ApiException as e:
    print("Exception when calling OpenvpnServerApi->openvpnServerPut: %s\n" % e)

Parameters

Body parameters
Name Description
body

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


openvpnServerRenewStaticKeyGet

Reset OpenVPN server's TLS static key which will be used to encrypt/authenticate control channel packets.


/openvpn/server/renew_static_key

Usage and SDK Samples

curl -X GET -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/openvpn/server/renew_static_key"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.OpenvpnServerApi;

import java.io.File;
import java.util.*;

public class OpenvpnServerApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        OpenvpnServerApi apiInstance = new OpenvpnServerApi();
        try {
            apiInstance.openvpnServerRenewStaticKeyGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling OpenvpnServerApi#openvpnServerRenewStaticKeyGet");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::OpenvpnServerApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::OpenvpnServerApi->new();

eval { 
    $api_instance->openvpnServerRenewStaticKeyGet();
};
if ($@) {
    warn "Exception when calling OpenvpnServerApi->openvpnServerRenewStaticKeyGet: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.OpenvpnServerApi()

try: 
    api_instance.openvpn_server_renew_static_key_get()
except ApiException as e:
    print("Exception when calling OpenvpnServerApi->openvpnServerRenewStaticKeyGet: %s\n" % e)

Parameters

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


Plugin

pluginAvailablePost

List available plugins which can be fetched for `plugin_repository`.


/plugin/available

Usage and SDK Samples

curl -X POST -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/plugin/available"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.PluginApi;

import java.io.File;
import java.util.*;

public class PluginApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        PluginApi apiInstance = new PluginApi();
        Plugin_available_0 body = ; // Plugin_available_0 | 
        try {
            apiInstance.pluginAvailablePost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling PluginApi#pluginAvailablePost");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::PluginApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::PluginApi->new();
my $body = WWW::SwaggerClient::Object::Plugin_available_0->new(); # Plugin_available_0 | 

eval { 
    $api_instance->pluginAvailablePost(body => $body);
};
if ($@) {
    warn "Exception when calling PluginApi->pluginAvailablePost: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.PluginApi()
body =  # Plugin_available_0 |  (optional)

try: 
    api_instance.plugin_available_post(body=body)
except ApiException as e:
    print("Exception when calling PluginApi->pluginAvailablePost: %s\n" % e)

Parameters

Body parameters
Name Description
body

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


pluginBranchesChoicesPost


/plugin/branches_choices

Usage and SDK Samples

curl -X POST -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/plugin/branches_choices"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.PluginApi;

import java.io.File;
import java.util.*;

public class PluginApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        PluginApi apiInstance = new PluginApi();
        String body = ; // String | 
        try {
            apiInstance.pluginBranchesChoicesPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling PluginApi#pluginBranchesChoicesPost");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::PluginApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::PluginApi->new();
my $body = WWW::SwaggerClient::Object::String->new(); # String | 

eval { 
    $api_instance->pluginBranchesChoicesPost(body => $body);
};
if ($@) {
    warn "Exception when calling PluginApi->pluginBranchesChoicesPost: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.PluginApi()
body =  # String |  (optional)

try: 
    api_instance.plugin_branches_choices_post(body=body)
except ApiException as e:
    print("Exception when calling PluginApi->pluginBranchesChoicesPost: %s\n" % e)

Parameters

Body parameters
Name Description
body

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


pluginDefaultsPost

Retrieve default properties specified for `plugin` in the plugin's manifest. When `refresh` is specified, `plugin_repository` is updated before retrieving plugin's default properties.


/plugin/defaults

Usage and SDK Samples

curl -X POST -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/plugin/defaults"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.PluginApi;

import java.io.File;
import java.util.*;

public class PluginApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        PluginApi apiInstance = new PluginApi();
        Plugin_defaults_0 body = ; // Plugin_defaults_0 | 
        try {
            apiInstance.pluginDefaultsPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling PluginApi#pluginDefaultsPost");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::PluginApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::PluginApi->new();
my $body = WWW::SwaggerClient::Object::Plugin_defaults_0->new(); # Plugin_defaults_0 | 

eval { 
    $api_instance->pluginDefaultsPost(body => $body);
};
if ($@) {
    warn "Exception when calling PluginApi->pluginDefaultsPost: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.PluginApi()
body =  # Plugin_defaults_0 |  (optional)

try: 
    api_instance.plugin_defaults_post(body=body)
except ApiException as e:
    print("Exception when calling PluginApi->pluginDefaultsPost: %s\n" % e)

Parameters

Body parameters
Name Description
body

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


pluginGet

Query installed plugins with `query-filters` and `query-options`.


/plugin

Usage and SDK Samples

curl -X GET -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/plugin?limit=&offset=&count=&sort="
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.PluginApi;

import java.io.File;
import java.util.*;

public class PluginApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        PluginApi apiInstance = new PluginApi();
        Integer limit = 56; // Integer | 
        Integer offset = 56; // Integer | 
        Boolean count = true; // Boolean | 
        String sort = sort_example; // String | 
        try {
            apiInstance.pluginGet(limit, offset, count, sort);
        } catch (ApiException e) {
            System.err.println("Exception when calling PluginApi#pluginGet");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::PluginApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::PluginApi->new();
my $limit = 56; # Integer | 
my $offset = 56; # Integer | 
my $count = true; # Boolean | 
my $sort = sort_example; # String | 

eval { 
    $api_instance->pluginGet(limit => $limit, offset => $offset, count => $count, sort => $sort);
};
if ($@) {
    warn "Exception when calling PluginApi->pluginGet: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.PluginApi()
limit = 56 # Integer |  (optional)
offset = 56 # Integer |  (optional)
count = true # Boolean |  (optional)
sort = sort_example # String |  (optional)

try: 
    api_instance.plugin_get(limit=limit, offset=offset, count=count, sort=sort)
except ApiException as e:
    print("Exception when calling PluginApi->pluginGet: %s\n" % e)

Parameters

Query parameters
Name Description
limit
Integer
offset
Integer
count
Boolean
sort
String

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


pluginIdIdDelete

Delete plugin `id`.


/plugin/id/{id}

Usage and SDK Samples

curl -X DELETE -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/plugin/id/{id}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.PluginApi;

import java.io.File;
import java.util.*;

public class PluginApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        PluginApi apiInstance = new PluginApi();
        String id = id_example; // String | 
        try {
            apiInstance.pluginIdIdDelete(id);
        } catch (ApiException e) {
            System.err.println("Exception when calling PluginApi#pluginIdIdDelete");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::PluginApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::PluginApi->new();
my $id = id_example; # String | 

eval { 
    $api_instance->pluginIdIdDelete(id => $id);
};
if ($@) {
    warn "Exception when calling PluginApi->pluginIdIdDelete: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.PluginApi()
id = id_example # String | 

try: 
    api_instance.plugin_id_id_delete(id)
except ApiException as e:
    print("Exception when calling PluginApi->pluginIdIdDelete: %s\n" % e)

Parameters

Path parameters
Name Description
id*
String
Required

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


pluginIdIdGet

Query installed plugins with `query-filters` and `query-options`.


/plugin/id/{id}

Usage and SDK Samples

curl -X GET -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/plugin/id/{id}?limit=&offset=&count=&sort="
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.PluginApi;

import java.io.File;
import java.util.*;

public class PluginApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        PluginApi apiInstance = new PluginApi();
        array[null] id = ; // array[null] | 
        Integer limit = 56; // Integer | 
        Integer offset = 56; // Integer | 
        Boolean count = true; // Boolean | 
        String sort = sort_example; // String | 
        try {
            apiInstance.pluginIdIdGet(id, limit, offset, count, sort);
        } catch (ApiException e) {
            System.err.println("Exception when calling PluginApi#pluginIdIdGet");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::PluginApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::PluginApi->new();
my $id = []; # array[null] | 
my $limit = 56; # Integer | 
my $offset = 56; # Integer | 
my $count = true; # Boolean | 
my $sort = sort_example; # String | 

eval { 
    $api_instance->pluginIdIdGet(id => $id, limit => $limit, offset => $offset, count => $count, sort => $sort);
};
if ($@) {
    warn "Exception when calling PluginApi->pluginIdIdGet: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.PluginApi()
id =  # array[null] | 
limit = 56 # Integer |  (optional)
offset = 56 # Integer |  (optional)
count = true # Boolean |  (optional)
sort = sort_example # String |  (optional)

try: 
    api_instance.plugin_id_id_get(id, limit=limit, offset=offset, count=count, sort=sort)
except ApiException as e:
    print("Exception when calling PluginApi->pluginIdIdGet: %s\n" % e)

Parameters

Path parameters
Name Description
id*
array[null]
Required
Query parameters
Name Description
limit
Integer
offset
Integer
count
Boolean
sort
String

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


pluginIdIdPut

Update plugin `id`.


/plugin/id/{id}

Usage and SDK Samples

curl -X PUT -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/plugin/id/{id}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.PluginApi;

import java.io.File;
import java.util.*;

public class PluginApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        PluginApi apiInstance = new PluginApi();
        String id = id_example; // String | 
        map[String, Object] body = ; // map[String, Object] | 
        try {
            apiInstance.pluginIdIdPut(id, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling PluginApi#pluginIdIdPut");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::PluginApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::PluginApi->new();
my $id = id_example; # String | 
my $body = WWW::SwaggerClient::Object::map[String, Object]->new(); # map[String, Object] | 

eval { 
    $api_instance->pluginIdIdPut(id => $id, body => $body);
};
if ($@) {
    warn "Exception when calling PluginApi->pluginIdIdPut: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.PluginApi()
id = id_example # String | 
body =  # map[String, Object] |  (optional)

try: 
    api_instance.plugin_id_id_put(id, body=body)
except ApiException as e:
    print("Exception when calling PluginApi->pluginIdIdPut: %s\n" % e)

Parameters

Path parameters
Name Description
id*
String
Required
Body parameters
Name Description
body

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


pluginOfficialRepositoriesGet

List officially supported plugin repositories.


/plugin/official_repositories

Usage and SDK Samples

curl -X GET -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/plugin/official_repositories"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.PluginApi;

import java.io.File;
import java.util.*;

public class PluginApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        PluginApi apiInstance = new PluginApi();
        try {
            apiInstance.pluginOfficialRepositoriesGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling PluginApi#pluginOfficialRepositoriesGet");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::PluginApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::PluginApi->new();

eval { 
    $api_instance->pluginOfficialRepositoriesGet();
};
if ($@) {
    warn "Exception when calling PluginApi->pluginOfficialRepositoriesGet: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.PluginApi()

try: 
    api_instance.plugin_official_repositories_get()
except ApiException as e:
    print("Exception when calling PluginApi->pluginOfficialRepositoriesGet: %s\n" % e)

Parameters

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


pluginPost

Create a Plugin. `plugin_name` is the name of the plugin specified by the INDEX file in "plugin_repository" and it's JSON file. `jail_name` is the name of the jail that will manage the plugin. Required. `props` is a list of jail properties that the user manually sets. Plugins should always set the jail networking capability with DHCP, IP Address, or NAT properties. i.e dhcp=1 / ip4_addr="192.168.0.2" / nat=1 `plugin_repository` is a git URI that fetches data for `plugin_name`. `branch` is the FreeNAS repository branch to use as the base for the `plugin_repository`. The default is to use the current system version. Example: 11.3-RELEASE.


/plugin

Usage and SDK Samples

curl -X POST -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/plugin"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.PluginApi;

import java.io.File;
import java.util.*;

public class PluginApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        PluginApi apiInstance = new PluginApi();
        Plugin_create_0 body = ; // Plugin_create_0 | 
        try {
            apiInstance.pluginPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling PluginApi#pluginPost");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::PluginApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::PluginApi->new();
my $body = WWW::SwaggerClient::Object::Plugin_create_0->new(); # Plugin_create_0 | 

eval { 
    $api_instance->pluginPost(body => $body);
};
if ($@) {
    warn "Exception when calling PluginApi->pluginPost: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.PluginApi()
body =  # Plugin_create_0 |  (optional)

try: 
    api_instance.plugin_post(body=body)
except ApiException as e:
    print("Exception when calling PluginApi->pluginPost: %s\n" % e)

Parameters

Body parameters
Name Description
body

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


pluginRetrieveVersionsForReposGet


/plugin/retrieve_versions_for_repos

Usage and SDK Samples

curl -X GET -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/plugin/retrieve_versions_for_repos"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.PluginApi;

import java.io.File;
import java.util.*;

public class PluginApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        PluginApi apiInstance = new PluginApi();
        try {
            apiInstance.pluginRetrieveVersionsForReposGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling PluginApi#pluginRetrieveVersionsForReposGet");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::PluginApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::PluginApi->new();

eval { 
    $api_instance->pluginRetrieveVersionsForReposGet();
};
if ($@) {
    warn "Exception when calling PluginApi->pluginRetrieveVersionsForReposGet: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.PluginApi()

try: 
    api_instance.plugin_retrieve_versions_for_repos_get()
except ApiException as e:
    print("Exception when calling PluginApi->pluginRetrieveVersionsForReposGet: %s\n" % e)

Parameters

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


Pool

poolAttachPost

For TrueNAS Core/Enterprise platform, if the `oid` pool is passphrase GELI encrypted, `passphrase` must be specified for this operation to succeed. `target_vdev` is the GUID of the vdev where the disk needs to be attached. In case of STRIPED vdev, this is the STRIPED disk GUID which will be converted to mirror. If `target_vdev` is mirror, it will be converted into a n-way mirror.


/pool/attach

Usage and SDK Samples

curl -X POST -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/pool/attach"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.PoolApi;

import java.io.File;
import java.util.*;

public class PoolApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        PoolApi apiInstance = new PoolApi();
        Pool_attach body = ; // Pool_attach | 
        try {
            apiInstance.poolAttachPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling PoolApi#poolAttachPost");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::PoolApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::PoolApi->new();
my $body = WWW::SwaggerClient::Object::Pool_attach->new(); # Pool_attach | 

eval { 
    $api_instance->poolAttachPost(body => $body);
};
if ($@) {
    warn "Exception when calling PoolApi->poolAttachPost: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.PoolApi()
body =  # Pool_attach |  (optional)

try: 
    api_instance.pool_attach_post(body=body)
except ApiException as e:
    print("Exception when calling PoolApi->poolAttachPost: %s\n" % e)

Parameters

Body parameters
Name Description
body

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


poolFilesystemChoicesPost

Returns all available datasets, except system datasets.


/pool/filesystem_choices

Usage and SDK Samples

curl -X POST -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/pool/filesystem_choices"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.PoolApi;

import java.io.File;
import java.util.*;

public class PoolApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        PoolApi apiInstance = new PoolApi();
        array[String] body = ; // array[String] | 
        try {
            apiInstance.poolFilesystemChoicesPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling PoolApi#poolFilesystemChoicesPost");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::PoolApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::PoolApi->new();
my $body = [WWW::SwaggerClient::Object::array[String]->new()]; # array[String] | 

eval { 
    $api_instance->poolFilesystemChoicesPost(body => $body);
};
if ($@) {
    warn "Exception when calling PoolApi->poolFilesystemChoicesPost: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.PoolApi()
body =  # array[String] |  (optional)

try: 
    api_instance.pool_filesystem_choices_post(body=body)
except ApiException as e:
    print("Exception when calling PoolApi->poolFilesystemChoicesPost: %s\n" % e)

Parameters

Body parameters
Name Description
body

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


poolGet


/pool

Usage and SDK Samples

curl -X GET -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/pool?limit=&offset=&count=&sort="
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.PoolApi;

import java.io.File;
import java.util.*;

public class PoolApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        PoolApi apiInstance = new PoolApi();
        Integer limit = 56; // Integer | 
        Integer offset = 56; // Integer | 
        Boolean count = true; // Boolean | 
        String sort = sort_example; // String | 
        try {
            apiInstance.poolGet(limit, offset, count, sort);
        } catch (ApiException e) {
            System.err.println("Exception when calling PoolApi#poolGet");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::PoolApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::PoolApi->new();
my $limit = 56; # Integer | 
my $offset = 56; # Integer | 
my $count = true; # Boolean | 
my $sort = sort_example; # String | 

eval { 
    $api_instance->poolGet(limit => $limit, offset => $offset, count => $count, sort => $sort);
};
if ($@) {
    warn "Exception when calling PoolApi->poolGet: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.PoolApi()
limit = 56 # Integer |  (optional)
offset = 56 # Integer |  (optional)
count = true # Boolean |  (optional)
sort = sort_example # String |  (optional)

try: 
    api_instance.pool_get(limit=limit, offset=offset, count=count, sort=sort)
except ApiException as e:
    print("Exception when calling PoolApi->poolGet: %s\n" % e)

Parameters

Query parameters
Name Description
limit
Integer
offset
Integer
count
Boolean
sort
String

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


poolIdIdAttachmentsPost

Return a list of services dependent of this pool. Responsible for telling the user whether there is a related share, asking for confirmation.


/pool/id/{id}/attachments

Usage and SDK Samples

curl -X POST -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/pool/id/{id}/attachments"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.PoolApi;

import java.io.File;
import java.util.*;

public class PoolApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        PoolApi apiInstance = new PoolApi();
        Integer id = 56; // Integer | 
        Pool_attachments body = ; // Pool_attachments | 
        try {
            apiInstance.poolIdIdAttachmentsPost(id, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling PoolApi#poolIdIdAttachmentsPost");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::PoolApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::PoolApi->new();
my $id = 56; # Integer | 
my $body = WWW::SwaggerClient::Object::Pool_attachments->new(); # Pool_attachments | 

eval { 
    $api_instance->poolIdIdAttachmentsPost(id => $id, body => $body);
};
if ($@) {
    warn "Exception when calling PoolApi->poolIdIdAttachmentsPost: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.PoolApi()
id = 56 # Integer | 
body =  # Pool_attachments |  (optional)

try: 
    api_instance.pool_id_id_attachments_post(id, body=body)
except ApiException as e:
    print("Exception when calling PoolApi->poolIdIdAttachmentsPost: %s\n" % e)

Parameters

Path parameters
Name Description
id*
Integer
Required
Body parameters
Name Description
body

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


poolIdIdDetachPost

Detach a disk from pool of id `id`. `label` is the vdev guid or device name.


/pool/id/{id}/detach

Usage and SDK Samples

curl -X POST -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/pool/id/{id}/detach"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.PoolApi;

import java.io.File;
import java.util.*;

public class PoolApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        PoolApi apiInstance = new PoolApi();
        Integer id = 56; // Integer | 
        Pool_detach_1 body = ; // Pool_detach_1 | 
        try {
            apiInstance.poolIdIdDetachPost(id, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling PoolApi#poolIdIdDetachPost");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::PoolApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::PoolApi->new();
my $id = 56; # Integer | 
my $body = WWW::SwaggerClient::Object::Pool_detach_1->new(); # Pool_detach_1 | 

eval { 
    $api_instance->poolIdIdDetachPost(id => $id, body => $body);
};
if ($@) {
    warn "Exception when calling PoolApi->poolIdIdDetachPost: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.PoolApi()
id = 56 # Integer | 
body =  # Pool_detach_1 |  (optional)

try: 
    api_instance.pool_id_id_detach_post(id, body=body)
except ApiException as e:
    print("Exception when calling PoolApi->poolIdIdDetachPost: %s\n" % e)

Parameters

Path parameters
Name Description
id*
Integer
Required
Body parameters
Name Description
body

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


poolIdIdDownloadEncryptionKeyPost

Download encryption key for a given pool `id`.


/pool/id/{id}/download_encryption_key

Usage and SDK Samples

curl -X POST -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/pool/id/{id}/download_encryption_key"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.PoolApi;

import java.io.File;
import java.util.*;

public class PoolApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        PoolApi apiInstance = new PoolApi();
        Integer id = 56; // Integer | 
        String body = ; // String | 
        try {
            apiInstance.poolIdIdDownloadEncryptionKeyPost(id, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling PoolApi#poolIdIdDownloadEncryptionKeyPost");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::PoolApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::PoolApi->new();
my $id = 56; # Integer | 
my $body = WWW::SwaggerClient::Object::String->new(); # String | 

eval { 
    $api_instance->poolIdIdDownloadEncryptionKeyPost(id => $id, body => $body);
};
if ($@) {
    warn "Exception when calling PoolApi->poolIdIdDownloadEncryptionKeyPost: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.PoolApi()
id = 56 # Integer | 
body =  # String |  (optional)

try: 
    api_instance.pool_id_id_download_encryption_key_post(id, body=body)
except ApiException as e:
    print("Exception when calling PoolApi->poolIdIdDownloadEncryptionKeyPost: %s\n" % e)

Parameters

Path parameters
Name Description
id*
Integer
Required
Body parameters
Name Description
body

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


poolIdIdExpandPost

Expand pool to fit all available disk space.


/pool/id/{id}/expand

Usage and SDK Samples

curl -X POST -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/pool/id/{id}/expand"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.PoolApi;

import java.io.File;
import java.util.*;

public class PoolApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        PoolApi apiInstance = new PoolApi();
        Integer id = 56; // Integer | 
        Pool_expand_1 body = ; // Pool_expand_1 | 
        try {
            apiInstance.poolIdIdExpandPost(id, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling PoolApi#poolIdIdExpandPost");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::PoolApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::PoolApi->new();
my $id = 56; # Integer | 
my $body = WWW::SwaggerClient::Object::Pool_expand_1->new(); # Pool_expand_1 | 

eval { 
    $api_instance->poolIdIdExpandPost(id => $id, body => $body);
};
if ($@) {
    warn "Exception when calling PoolApi->poolIdIdExpandPost: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.PoolApi()
id = 56 # Integer | 
body =  # Pool_expand_1 |  (optional)

try: 
    api_instance.pool_id_id_expand_post(id, body=body)
except ApiException as e:
    print("Exception when calling PoolApi->poolIdIdExpandPost: %s\n" % e)

Parameters

Path parameters
Name Description
id*
Integer
Required
Body parameters
Name Description
body

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


poolIdIdExportPost

Export pool of `id`. `cascade` will delete all attachments of the given pool (`pool.attachments`). `restart_services` will restart services that have open files on given pool. `destroy` will also PERMANENTLY destroy the pool/data.


/pool/id/{id}/export

Usage and SDK Samples

curl -X POST -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/pool/id/{id}/export"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.PoolApi;

import java.io.File;
import java.util.*;

public class PoolApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        PoolApi apiInstance = new PoolApi();
        Integer id = 56; // Integer | 
        Pool_export_1 body = ; // Pool_export_1 | 
        try {
            apiInstance.poolIdIdExportPost(id, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling PoolApi#poolIdIdExportPost");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::PoolApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::PoolApi->new();
my $id = 56; # Integer | 
my $body = WWW::SwaggerClient::Object::Pool_export_1->new(); # Pool_export_1 | 

eval { 
    $api_instance->poolIdIdExportPost(id => $id, body => $body);
};
if ($@) {
    warn "Exception when calling PoolApi->poolIdIdExportPost: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.PoolApi()
id = 56 # Integer | 
body =  # Pool_export_1 |  (optional)

try: 
    api_instance.pool_id_id_export_post(id, body=body)
except ApiException as e:
    print("Exception when calling PoolApi->poolIdIdExportPost: %s\n" % e)

Parameters

Path parameters
Name Description
id*
Integer
Required
Body parameters
Name Description
body

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


poolIdIdGet


/pool/id/{id}

Usage and SDK Samples

curl -X GET -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/pool/id/{id}?limit=&offset=&count=&sort="
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.PoolApi;

import java.io.File;
import java.util.*;

public class PoolApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        PoolApi apiInstance = new PoolApi();
        array[null] id = ; // array[null] | 
        Integer limit = 56; // Integer | 
        Integer offset = 56; // Integer | 
        Boolean count = true; // Boolean | 
        String sort = sort_example; // String | 
        try {
            apiInstance.poolIdIdGet(id, limit, offset, count, sort);
        } catch (ApiException e) {
            System.err.println("Exception when calling PoolApi#poolIdIdGet");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::PoolApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::PoolApi->new();
my $id = []; # array[null] | 
my $limit = 56; # Integer | 
my $offset = 56; # Integer | 
my $count = true; # Boolean | 
my $sort = sort_example; # String | 

eval { 
    $api_instance->poolIdIdGet(id => $id, limit => $limit, offset => $offset, count => $count, sort => $sort);
};
if ($@) {
    warn "Exception when calling PoolApi->poolIdIdGet: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.PoolApi()
id =  # array[null] | 
limit = 56 # Integer |  (optional)
offset = 56 # Integer |  (optional)
count = true # Boolean |  (optional)
sort = sort_example # String |  (optional)

try: 
    api_instance.pool_id_id_get(id, limit=limit, offset=offset, count=count, sort=sort)
except ApiException as e:
    print("Exception when calling PoolApi->poolIdIdGet: %s\n" % e)

Parameters

Path parameters
Name Description
id*
array[null]
Required
Query parameters
Name Description
limit
Integer
offset
Integer
count
Boolean
sort
String

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


poolIdIdGetDisksPost

Get all disks in use by pools. If `id` is provided only the disks from the given pool `id` will be returned.


/pool/id/{id}/get_disks

Usage and SDK Samples

curl -X POST -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/pool/id/{id}/get_disks"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.PoolApi;

import java.io.File;
import java.util.*;

public class PoolApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        PoolApi apiInstance = new PoolApi();
        Integer id = 56; // Integer | 
        Pool_get_disks body = ; // Pool_get_disks | 
        try {
            apiInstance.poolIdIdGetDisksPost(id, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling PoolApi#poolIdIdGetDisksPost");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::PoolApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::PoolApi->new();
my $id = 56; # Integer | 
my $body = WWW::SwaggerClient::Object::Pool_get_disks->new(); # Pool_get_disks | 

eval { 
    $api_instance->poolIdIdGetDisksPost(id => $id, body => $body);
};
if ($@) {
    warn "Exception when calling PoolApi->poolIdIdGetDisksPost: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.PoolApi()
id = 56 # Integer | 
body =  # Pool_get_disks |  (optional)

try: 
    api_instance.pool_id_id_get_disks_post(id, body=body)
except ApiException as e:
    print("Exception when calling PoolApi->poolIdIdGetDisksPost: %s\n" % e)

Parameters

Path parameters
Name Description
id*
Integer
Required
Body parameters
Name Description
body

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


poolIdIdIsUpgradedPost

Returns whether or not the pool of `id` is on the latest version and with all feature flags enabled.


/pool/id/{id}/is_upgraded

Usage and SDK Samples

curl -X POST -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/pool/id/{id}/is_upgraded"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.PoolApi;

import java.io.File;
import java.util.*;

public class PoolApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        PoolApi apiInstance = new PoolApi();
        Integer id = 56; // Integer | 
        Pool_is_upgraded body = ; // Pool_is_upgraded | 
        try {
            apiInstance.poolIdIdIsUpgradedPost(id, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling PoolApi#poolIdIdIsUpgradedPost");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::PoolApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::PoolApi->new();
my $id = 56; # Integer | 
my $body = WWW::SwaggerClient::Object::Pool_is_upgraded->new(); # Pool_is_upgraded | 

eval { 
    $api_instance->poolIdIdIsUpgradedPost(id => $id, body => $body);
};
if ($@) {
    warn "Exception when calling PoolApi->poolIdIdIsUpgradedPost: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.PoolApi()
id = 56 # Integer | 
body =  # Pool_is_upgraded |  (optional)

try: 
    api_instance.pool_id_id_is_upgraded_post(id, body=body)
except ApiException as e:
    print("Exception when calling PoolApi->poolIdIdIsUpgradedPost: %s\n" % e)

Parameters

Path parameters
Name Description
id*
Integer
Required
Body parameters
Name Description
body

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


poolIdIdLockPost

Lock encrypted pool `id`.


/pool/id/{id}/lock

Usage and SDK Samples

curl -X POST -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/pool/id/{id}/lock"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.PoolApi;

import java.io.File;
import java.util.*;

public class PoolApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        PoolApi apiInstance = new PoolApi();
        Integer id = 56; // Integer | 
        String body = ; // String | 
        try {
            apiInstance.poolIdIdLockPost(id, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling PoolApi#poolIdIdLockPost");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::PoolApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::PoolApi->new();
my $id = 56; # Integer | 
my $body = WWW::SwaggerClient::Object::String->new(); # String | 

eval { 
    $api_instance->poolIdIdLockPost(id => $id, body => $body);
};
if ($@) {
    warn "Exception when calling PoolApi->poolIdIdLockPost: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.PoolApi()
id = 56 # Integer | 
body =  # String |  (optional)

try: 
    api_instance.pool_id_id_lock_post(id, body=body)
except ApiException as e:
    print("Exception when calling PoolApi->poolIdIdLockPost: %s\n" % e)

Parameters

Path parameters
Name Description
id*
Integer
Required
Body parameters
Name Description
body

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


poolIdIdOfflinePost

Offline a disk from pool of id `id`. `label` is the vdev guid or device name.


/pool/id/{id}/offline

Usage and SDK Samples

curl -X POST -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/pool/id/{id}/offline"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.PoolApi;

import java.io.File;
import java.util.*;

public class PoolApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        PoolApi apiInstance = new PoolApi();
        Integer id = 56; // Integer | 
        Pool_offline_1 body = ; // Pool_offline_1 | 
        try {
            apiInstance.poolIdIdOfflinePost(id, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling PoolApi#poolIdIdOfflinePost");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::PoolApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::PoolApi->new();
my $id = 56; # Integer | 
my $body = WWW::SwaggerClient::Object::Pool_offline_1->new(); # Pool_offline_1 | 

eval { 
    $api_instance->poolIdIdOfflinePost(id => $id, body => $body);
};
if ($@) {
    warn "Exception when calling PoolApi->poolIdIdOfflinePost: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.PoolApi()
id = 56 # Integer | 
body =  # Pool_offline_1 |  (optional)

try: 
    api_instance.pool_id_id_offline_post(id, body=body)
except ApiException as e:
    print("Exception when calling PoolApi->poolIdIdOfflinePost: %s\n" % e)

Parameters

Path parameters
Name Description
id*
Integer
Required
Body parameters
Name Description
body

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


poolIdIdOnlinePost

Online a disk from pool of id `id`. `label` is the vdev guid or device name.


/pool/id/{id}/online

Usage and SDK Samples

curl -X POST -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/pool/id/{id}/online"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.PoolApi;

import java.io.File;
import java.util.*;

public class PoolApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        PoolApi apiInstance = new PoolApi();
        Integer id = 56; // Integer | 
        Pool_online_1 body = ; // Pool_online_1 | 
        try {
            apiInstance.poolIdIdOnlinePost(id, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling PoolApi#poolIdIdOnlinePost");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::PoolApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::PoolApi->new();
my $id = 56; # Integer | 
my $body = WWW::SwaggerClient::Object::Pool_online_1->new(); # Pool_online_1 | 

eval { 
    $api_instance->poolIdIdOnlinePost(id => $id, body => $body);
};
if ($@) {
    warn "Exception when calling PoolApi->poolIdIdOnlinePost: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.PoolApi()
id = 56 # Integer | 
body =  # Pool_online_1 |  (optional)

try: 
    api_instance.pool_id_id_online_post(id, body=body)
except ApiException as e:
    print("Exception when calling PoolApi->poolIdIdOnlinePost: %s\n" % e)

Parameters

Path parameters
Name Description
id*
Integer
Required
Body parameters
Name Description
body

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


poolIdIdPassphrasePost

Create/Change/Remove passphrase for an encrypted pool. Setting passphrase to null will remove the passphrase. `admin_password` is required when changing or removing passphrase.


/pool/id/{id}/passphrase

Usage and SDK Samples

curl -X POST -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/pool/id/{id}/passphrase"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.PoolApi;

import java.io.File;
import java.util.*;

public class PoolApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        PoolApi apiInstance = new PoolApi();
        Integer id = 56; // Integer | 
        Pool_passphrase_1 body = ; // Pool_passphrase_1 | 
        try {
            apiInstance.poolIdIdPassphrasePost(id, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling PoolApi#poolIdIdPassphrasePost");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::PoolApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::PoolApi->new();
my $id = 56; # Integer | 
my $body = WWW::SwaggerClient::Object::Pool_passphrase_1->new(); # Pool_passphrase_1 | 

eval { 
    $api_instance->poolIdIdPassphrasePost(id => $id, body => $body);
};
if ($@) {
    warn "Exception when calling PoolApi->poolIdIdPassphrasePost: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.PoolApi()
id = 56 # Integer | 
body =  # Pool_passphrase_1 |  (optional)

try: 
    api_instance.pool_id_id_passphrase_post(id, body=body)
except ApiException as e:
    print("Exception when calling PoolApi->poolIdIdPassphrasePost: %s\n" % e)

Parameters

Path parameters
Name Description
id*
Integer
Required
Body parameters
Name Description
body

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


poolIdIdProcessesPost

Returns a list of running processes using this pool.


/pool/id/{id}/processes

Usage and SDK Samples

curl -X POST -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/pool/id/{id}/processes"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.PoolApi;

import java.io.File;
import java.util.*;

public class PoolApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        PoolApi apiInstance = new PoolApi();
        Integer id = 56; // Integer | 
        Pool_processes body = ; // Pool_processes | 
        try {
            apiInstance.poolIdIdProcessesPost(id, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling PoolApi#poolIdIdProcessesPost");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::PoolApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::PoolApi->new();
my $id = 56; # Integer | 
my $body = WWW::SwaggerClient::Object::Pool_processes->new(); # Pool_processes | 

eval { 
    $api_instance->poolIdIdProcessesPost(id => $id, body => $body);
};
if ($@) {
    warn "Exception when calling PoolApi->poolIdIdProcessesPost: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.PoolApi()
id = 56 # Integer | 
body =  # Pool_processes |  (optional)

try: 
    api_instance.pool_id_id_processes_post(id, body=body)
except ApiException as e:
    print("Exception when calling PoolApi->poolIdIdProcessesPost: %s\n" % e)

Parameters

Path parameters
Name Description
id*
Integer
Required
Body parameters
Name Description
body

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


poolIdIdPut

Update pool of `id`, adding the new topology. The `type` of `data` must be the same of existing vdevs.


/pool/id/{id}

Usage and SDK Samples

curl -X PUT -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/pool/id/{id}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.PoolApi;

import java.io.File;
import java.util.*;

public class PoolApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        PoolApi apiInstance = new PoolApi();
        Integer id = 56; // Integer | 
        Pool_update_1 body = ; // Pool_update_1 | 
        try {
            apiInstance.poolIdIdPut(id, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling PoolApi#poolIdIdPut");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::PoolApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::PoolApi->new();
my $id = 56; # Integer | 
my $body = WWW::SwaggerClient::Object::Pool_update_1->new(); # Pool_update_1 | 

eval { 
    $api_instance->poolIdIdPut(id => $id, body => $body);
};
if ($@) {
    warn "Exception when calling PoolApi->poolIdIdPut: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.PoolApi()
id = 56 # Integer | 
body =  # Pool_update_1 |  (optional)

try: 
    api_instance.pool_id_id_put(id, body=body)
except ApiException as e:
    print("Exception when calling PoolApi->poolIdIdPut: %s\n" % e)

Parameters

Path parameters
Name Description
id*
Integer
Required
Body parameters
Name Description
body

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


poolIdIdRecoverykeyRmPost

Remove recovery key for encrypted pool `id`.


/pool/id/{id}/recoverykey_rm

Usage and SDK Samples

curl -X POST -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/pool/id/{id}/recoverykey_rm"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.PoolApi;

import java.io.File;
import java.util.*;

public class PoolApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        PoolApi apiInstance = new PoolApi();
        Integer id = 56; // Integer | 
        Pool_recoverykey_rm_1 body = ; // Pool_recoverykey_rm_1 | 
        try {
            apiInstance.poolIdIdRecoverykeyRmPost(id, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling PoolApi#poolIdIdRecoverykeyRmPost");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::PoolApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::PoolApi->new();
my $id = 56; # Integer | 
my $body = WWW::SwaggerClient::Object::Pool_recoverykey_rm_1->new(); # Pool_recoverykey_rm_1 | 

eval { 
    $api_instance->poolIdIdRecoverykeyRmPost(id => $id, body => $body);
};
if ($@) {
    warn "Exception when calling PoolApi->poolIdIdRecoverykeyRmPost: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.PoolApi()
id = 56 # Integer | 
body =  # Pool_recoverykey_rm_1 |  (optional)

try: 
    api_instance.pool_id_id_recoverykey_rm_post(id, body=body)
except ApiException as e:
    print("Exception when calling PoolApi->poolIdIdRecoverykeyRmPost: %s\n" % e)

Parameters

Path parameters
Name Description
id*
Integer
Required
Body parameters
Name Description
body

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


poolIdIdRekeyPost

Rekey encrypted pool `id`.


/pool/id/{id}/rekey

Usage and SDK Samples

curl -X POST -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/pool/id/{id}/rekey"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.PoolApi;

import java.io.File;
import java.util.*;

public class PoolApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        PoolApi apiInstance = new PoolApi();
        Integer id = 56; // Integer | 
        Pool_rekey_1 body = ; // Pool_rekey_1 | 
        try {
            apiInstance.poolIdIdRekeyPost(id, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling PoolApi#poolIdIdRekeyPost");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::PoolApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::PoolApi->new();
my $id = 56; # Integer | 
my $body = WWW::SwaggerClient::Object::Pool_rekey_1->new(); # Pool_rekey_1 | 

eval { 
    $api_instance->poolIdIdRekeyPost(id => $id, body => $body);
};
if ($@) {
    warn "Exception when calling PoolApi->poolIdIdRekeyPost: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.PoolApi()
id = 56 # Integer | 
body =  # Pool_rekey_1 |  (optional)

try: 
    api_instance.pool_id_id_rekey_post(id, body=body)
except ApiException as e:
    print("Exception when calling PoolApi->poolIdIdRekeyPost: %s\n" % e)

Parameters

Path parameters
Name Description
id*
Integer
Required
Body parameters
Name Description
body

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


poolIdIdRemovePost

Remove a disk from pool of id `id`. `label` is the vdev guid or device name. Error codes: EZFS_NOSPC(2032): out of space to remove a device EZFS_NODEVICE(2017): no such device in pool EZFS_NOREPLICAS(2019): no valid replicas


/pool/id/{id}/remove

Usage and SDK Samples

curl -X POST -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/pool/id/{id}/remove"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.PoolApi;

import java.io.File;
import java.util.*;

public class PoolApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        PoolApi apiInstance = new PoolApi();
        Integer id = 56; // Integer | 
        Pool_remove_1 body = ; // Pool_remove_1 | 
        try {
            apiInstance.poolIdIdRemovePost(id, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling PoolApi#poolIdIdRemovePost");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::PoolApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::PoolApi->new();
my $id = 56; # Integer | 
my $body = WWW::SwaggerClient::Object::Pool_remove_1->new(); # Pool_remove_1 | 

eval { 
    $api_instance->poolIdIdRemovePost(id => $id, body => $body);
};
if ($@) {
    warn "Exception when calling PoolApi->poolIdIdRemovePost: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.PoolApi()
id = 56 # Integer | 
body =  # Pool_remove_1 |  (optional)

try: 
    api_instance.pool_id_id_remove_post(id, body=body)
except ApiException as e:
    print("Exception when calling PoolApi->poolIdIdRemovePost: %s\n" % e)

Parameters

Path parameters
Name Description
id*
Integer
Required
Body parameters
Name Description
body

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


poolIdIdReplacePost

Replace a disk on a pool. `label` is the ZFS guid or a device name `disk` is the identifier of a disk `passphrase` is only valid for TrueNAS Core/Enterprise platform where pool is GELI encrypted


/pool/id/{id}/replace

Usage and SDK Samples

curl -X POST -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/pool/id/{id}/replace"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.PoolApi;

import java.io.File;
import java.util.*;

public class PoolApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        PoolApi apiInstance = new PoolApi();
        Integer id = 56; // Integer | 
        Pool_replace_1 body = ; // Pool_replace_1 | 
        try {
            apiInstance.poolIdIdReplacePost(id, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling PoolApi#poolIdIdReplacePost");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::PoolApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::PoolApi->new();
my $id = 56; # Integer | 
my $body = WWW::SwaggerClient::Object::Pool_replace_1->new(); # Pool_replace_1 | 

eval { 
    $api_instance->poolIdIdReplacePost(id => $id, body => $body);
};
if ($@) {
    warn "Exception when calling PoolApi->poolIdIdReplacePost: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.PoolApi()
id = 56 # Integer | 
body =  # Pool_replace_1 |  (optional)

try: 
    api_instance.pool_id_id_replace_post(id, body=body)
except ApiException as e:
    print("Exception when calling PoolApi->poolIdIdReplacePost: %s\n" % e)

Parameters

Path parameters
Name Description
id*
Integer
Required
Body parameters
Name Description
body

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


poolIdIdScrubPost

Performs a scrub action to pool of `id`. `action` can be either of "START", "STOP" or "PAUSE".


/pool/id/{id}/scrub

Usage and SDK Samples

curl -X POST -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/pool/id/{id}/scrub"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.PoolApi;

import java.io.File;
import java.util.*;

public class PoolApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        PoolApi apiInstance = new PoolApi();
        Integer id = 56; // Integer | 
        String body = ; // String | 
        try {
            apiInstance.poolIdIdScrubPost(id, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling PoolApi#poolIdIdScrubPost");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::PoolApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::PoolApi->new();
my $id = 56; # Integer | 
my $body = WWW::SwaggerClient::Object::String->new(); # String | 

eval { 
    $api_instance->poolIdIdScrubPost(id => $id, body => $body);
};
if ($@) {
    warn "Exception when calling PoolApi->poolIdIdScrubPost: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.PoolApi()
id = 56 # Integer | 
body =  # String |  (optional)

try: 
    api_instance.pool_id_id_scrub_post(id, body=body)
except ApiException as e:
    print("Exception when calling PoolApi->poolIdIdScrubPost: %s\n" % e)

Parameters

Path parameters
Name Description
id*
Integer
Required
Body parameters
Name Description
body

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


poolIdIdUnlockPost

Unlock encrypted pool `id`. `passphrase` is required of a recovery key is not provided. If `recoverykey` is true this method expects the recovery key file to be uploaded using the /_upload/ endpoint. `services_restart` is a list of services to be restarted when the pool gets unlocked. Said list be be retrieve using `pool.unlock_services_restart_choices`. A file can be uploaded to this end point. This end point is special, please refer to Jobs section in Websocket API documentation for details.


/pool/id/{id}/unlock

Usage and SDK Samples

curl -X POST -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/pool/id/{id}/unlock"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.PoolApi;

import java.io.File;
import java.util.*;

public class PoolApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        PoolApi apiInstance = new PoolApi();
        Integer id = 56; // Integer | 
        Pool_unlock_1 body = ; // Pool_unlock_1 | 
        try {
            apiInstance.poolIdIdUnlockPost(id, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling PoolApi#poolIdIdUnlockPost");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::PoolApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::PoolApi->new();
my $id = 56; # Integer | 
my $body = WWW::SwaggerClient::Object::Pool_unlock_1->new(); # Pool_unlock_1 | 

eval { 
    $api_instance->poolIdIdUnlockPost(id => $id, body => $body);
};
if ($@) {
    warn "Exception when calling PoolApi->poolIdIdUnlockPost: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.PoolApi()
id = 56 # Integer | 
body =  # Pool_unlock_1 |  (optional)

try: 
    api_instance.pool_id_id_unlock_post(id, body=body)
except ApiException as e:
    print("Exception when calling PoolApi->poolIdIdUnlockPost: %s\n" % e)

Parameters

Path parameters
Name Description
id*
Integer
Required
Body parameters
Name Description
body

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


poolIdIdUpgradePost

Upgrade pool of `id` to latest version with all feature flags.


/pool/id/{id}/upgrade

Usage and SDK Samples

curl -X POST -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/pool/id/{id}/upgrade"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.PoolApi;

import java.io.File;
import java.util.*;

public class PoolApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        PoolApi apiInstance = new PoolApi();
        Integer id = 56; // Integer | 
        Pool_upgrade body = ; // Pool_upgrade | 
        try {
            apiInstance.poolIdIdUpgradePost(id, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling PoolApi#poolIdIdUpgradePost");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::PoolApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::PoolApi->new();
my $id = 56; # Integer | 
my $body = WWW::SwaggerClient::Object::Pool_upgrade->new(); # Pool_upgrade | 

eval { 
    $api_instance->poolIdIdUpgradePost(id => $id, body => $body);
};
if ($@) {
    warn "Exception when calling PoolApi->poolIdIdUpgradePost: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.PoolApi()
id = 56 # Integer | 
body =  # Pool_upgrade |  (optional)

try: 
    api_instance.pool_id_id_upgrade_post(id, body=body)
except ApiException as e:
    print("Exception when calling PoolApi->poolIdIdUpgradePost: %s\n" % e)

Parameters

Path parameters
Name Description
id*
Integer
Required
Body parameters
Name Description
body

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


poolImportDiskAutodetectFsTypePost

Autodetect filesystem type for `pool.import_disk`.


/pool/import_disk_autodetect_fs_type

Usage and SDK Samples

curl -X POST -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/pool/import_disk_autodetect_fs_type"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.PoolApi;

import java.io.File;
import java.util.*;

public class PoolApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        PoolApi apiInstance = new PoolApi();
        String body = ; // String | 
        try {
            apiInstance.poolImportDiskAutodetectFsTypePost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling PoolApi#poolImportDiskAutodetectFsTypePost");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::PoolApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::PoolApi->new();
my $body = WWW::SwaggerClient::Object::String->new(); # String | 

eval { 
    $api_instance->poolImportDiskAutodetectFsTypePost(body => $body);
};
if ($@) {
    warn "Exception when calling PoolApi->poolImportDiskAutodetectFsTypePost: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.PoolApi()
body =  # String |  (optional)

try: 
    api_instance.pool_import_disk_autodetect_fs_type_post(body=body)
except ApiException as e:
    print("Exception when calling PoolApi->poolImportDiskAutodetectFsTypePost: %s\n" % e)

Parameters

Body parameters
Name Description
body

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


poolImportDiskMsdosfsLocalesGet

Get a list of locales for msdosfs type to be used in `pool.import_disk`.


/pool/import_disk_msdosfs_locales

Usage and SDK Samples

curl -X GET -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/pool/import_disk_msdosfs_locales"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.PoolApi;

import java.io.File;
import java.util.*;

public class PoolApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        PoolApi apiInstance = new PoolApi();
        try {
            apiInstance.poolImportDiskMsdosfsLocalesGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling PoolApi#poolImportDiskMsdosfsLocalesGet");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::PoolApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::PoolApi->new();

eval { 
    $api_instance->poolImportDiskMsdosfsLocalesGet();
};
if ($@) {
    warn "Exception when calling PoolApi->poolImportDiskMsdosfsLocalesGet: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.PoolApi()

try: 
    api_instance.pool_import_disk_msdosfs_locales_get()
except ApiException as e:
    print("Exception when calling PoolApi->poolImportDiskMsdosfsLocalesGet: %s\n" % e)

Parameters

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


poolImportDiskPost

Import a disk, by copying its content to a pool.


/pool/import_disk

Usage and SDK Samples

curl -X POST -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/pool/import_disk"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.PoolApi;

import java.io.File;
import java.util.*;

public class PoolApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        PoolApi apiInstance = new PoolApi();
        Pool_import_disk body = ; // Pool_import_disk | 
        try {
            apiInstance.poolImportDiskPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling PoolApi#poolImportDiskPost");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::PoolApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::PoolApi->new();
my $body = WWW::SwaggerClient::Object::Pool_import_disk->new(); # Pool_import_disk | 

eval { 
    $api_instance->poolImportDiskPost(body => $body);
};
if ($@) {
    warn "Exception when calling PoolApi->poolImportDiskPost: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.PoolApi()
body =  # Pool_import_disk |  (optional)

try: 
    api_instance.pool_import_disk_post(body=body)
except ApiException as e:
    print("Exception when calling PoolApi->poolImportDiskPost: %s\n" % e)

Parameters

Body parameters
Name Description
body

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


poolImportFindGet

Returns a job id which can be used to retrieve a list of pools available for import with the following details as a result of the job: name, guid, status, hostname.


/pool/import_find

Usage and SDK Samples

curl -X GET -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/pool/import_find"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.PoolApi;

import java.io.File;
import java.util.*;

public class PoolApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        PoolApi apiInstance = new PoolApi();
        try {
            apiInstance.poolImportFindGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling PoolApi#poolImportFindGet");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::PoolApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::PoolApi->new();

eval { 
    $api_instance->poolImportFindGet();
};
if ($@) {
    warn "Exception when calling PoolApi->poolImportFindGet: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.PoolApi()

try: 
    api_instance.pool_import_find_get()
except ApiException as e:
    print("Exception when calling PoolApi->poolImportFindGet: %s\n" % e)

Parameters

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


poolImportPoolPost

Import a pool found with `pool.import_find`. If a `name` is specified the pool will be imported using that new name. `passphrase` is required while importing an encrypted pool. In that case this method needs to be called using /_upload/ endpoint with the encryption key. If `enable_attachments` is set to true, attachments that were disabled during pool export will be re-enabled. Errors: ENOENT - Pool not found A file can be uploaded to this end point. This end point is special, please refer to Jobs section in Websocket API documentation for details.


/pool/import_pool

Usage and SDK Samples

curl -X POST -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/pool/import_pool"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.PoolApi;

import java.io.File;
import java.util.*;

public class PoolApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        PoolApi apiInstance = new PoolApi();
        Pool_import_pool_0 body = ; // Pool_import_pool_0 | 
        try {
            apiInstance.poolImportPoolPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling PoolApi#poolImportPoolPost");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::PoolApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::PoolApi->new();
my $body = WWW::SwaggerClient::Object::Pool_import_pool_0->new(); # Pool_import_pool_0 | 

eval { 
    $api_instance->poolImportPoolPost(body => $body);
};
if ($@) {
    warn "Exception when calling PoolApi->poolImportPoolPost: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.PoolApi()
body =  # Pool_import_pool_0 |  (optional)

try: 
    api_instance.pool_import_pool_post(body=body)
except ApiException as e:
    print("Exception when calling PoolApi->poolImportPoolPost: %s\n" % e)

Parameters

Body parameters
Name Description
body

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


poolPost

Create a new ZFS Pool. `topology` is a object which requires at least one `data` entry. All of `data` entries (vdevs) require to be of the same type. `deduplication` when set to ON or VERIFY makes sure that no block of data is duplicated in the pool. When VERIFY is specified, if two blocks have similar signatures, byte to byte comparison is performed to ensure that the blocks are identical. This should be used in special circumstances as it carries a significant overhead. `encryption` when enabled will create an ZFS encrypted root dataset for `name` pool. `encryption_options` specifies configuration for encryption of root dataset for `name` pool. `encryption_options.passphrase` must be specified if encryption for root dataset is desired with a passphrase as a key. Otherwise a hex encoded key can be specified by providing `encryption_options.key`. `encryption_options.generate_key` when enabled automatically generates the key to be used for dataset encryption. It should be noted that keys are stored by the system for automatic locking/unlocking on import/export of encrypted datasets. If that is not desired, dataset should be created with a passphrase as a key. Example of `topology`: { "data": [ {"type": "RAIDZ1", "disks": ["da1", "da2", "da3"]} ], "cache": [ {"type": "STRIPE", "disks": ["da4"]} ], "log": [ {"type": "STRIPE", "disks": ["da5"]} ], "spares": ["da6"] }


/pool

Usage and SDK Samples

curl -X POST -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/pool"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.PoolApi;

import java.io.File;
import java.util.*;

public class PoolApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        PoolApi apiInstance = new PoolApi();
        Pool_create_0 body = ; // Pool_create_0 | 
        try {
            apiInstance.poolPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling PoolApi#poolPost");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::PoolApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::PoolApi->new();
my $body = WWW::SwaggerClient::Object::Pool_create_0->new(); # Pool_create_0 | 

eval { 
    $api_instance->poolPost(body => $body);
};
if ($@) {
    warn "Exception when calling PoolApi->poolPost: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.PoolApi()
body =  # Pool_create_0 |  (optional)

try: 
    api_instance.pool_post(body=body)
except ApiException as e:
    print("Exception when calling PoolApi->poolPost: %s\n" % e)

Parameters

Body parameters
Name Description
body

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


poolUnlockServicesRestartChoicesPost

Get a mapping of services identifiers and labels that can be restart on volume unlock.


/pool/unlock_services_restart_choices

Usage and SDK Samples

curl -X POST -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/pool/unlock_services_restart_choices"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.PoolApi;

import java.io.File;
import java.util.*;

public class PoolApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        PoolApi apiInstance = new PoolApi();
        Integer body = ; // Integer | 
        try {
            apiInstance.poolUnlockServicesRestartChoicesPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling PoolApi#poolUnlockServicesRestartChoicesPost");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::PoolApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::PoolApi->new();
my $body = WWW::SwaggerClient::Object::Integer->new(); # Integer | 

eval { 
    $api_instance->poolUnlockServicesRestartChoicesPost(body => $body);
};
if ($@) {
    warn "Exception when calling PoolApi->poolUnlockServicesRestartChoicesPost: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.PoolApi()
body =  # Integer |  (optional)

try: 
    api_instance.pool_unlock_services_restart_choices_post(body=body)
except ApiException as e:
    print("Exception when calling PoolApi->poolUnlockServicesRestartChoicesPost: %s\n" % e)

Parameters

Body parameters
Name Description
body

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


PoolDataset

poolDatasetChangeKeyPost

Change encryption properties for `id` encrypted dataset. Changing dataset encryption to use passphrase instead of a key is not allowed if: 1) It has encrypted roots as children which are encrypted with a key 2) If it is a root dataset where the system dataset is located A file can be uploaded to this end point. This end point is special, please refer to Jobs section in Websocket API documentation for details.


/pool/dataset/change_key

Usage and SDK Samples

curl -X POST -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/pool/dataset/change_key"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.PoolDatasetApi;

import java.io.File;
import java.util.*;

public class PoolDatasetApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        PoolDatasetApi apiInstance = new PoolDatasetApi();
        Pool_dataset_change_key body = ; // Pool_dataset_change_key | 
        try {
            apiInstance.poolDatasetChangeKeyPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling PoolDatasetApi#poolDatasetChangeKeyPost");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::PoolDatasetApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::PoolDatasetApi->new();
my $body = WWW::SwaggerClient::Object::Pool_dataset_change_key->new(); # Pool_dataset_change_key | 

eval { 
    $api_instance->poolDatasetChangeKeyPost(body => $body);
};
if ($@) {
    warn "Exception when calling PoolDatasetApi->poolDatasetChangeKeyPost: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.PoolDatasetApi()
body =  # Pool_dataset_change_key |  (optional)

try: 
    api_instance.pool_dataset_change_key_post(body=body)
except ApiException as e:
    print("Exception when calling PoolDatasetApi->poolDatasetChangeKeyPost: %s\n" % e)

Parameters

Body parameters
Name Description
body

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


poolDatasetEncryptionAlgorithmChoicesGet

Retrieve encryption algorithms supported for ZFS dataset encryption.


/pool/dataset/encryption_algorithm_choices

Usage and SDK Samples

curl -X GET -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/pool/dataset/encryption_algorithm_choices"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.PoolDatasetApi;

import java.io.File;
import java.util.*;

public class PoolDatasetApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        PoolDatasetApi apiInstance = new PoolDatasetApi();
        try {
            apiInstance.poolDatasetEncryptionAlgorithmChoicesGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling PoolDatasetApi#poolDatasetEncryptionAlgorithmChoicesGet");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::PoolDatasetApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::PoolDatasetApi->new();

eval { 
    $api_instance->poolDatasetEncryptionAlgorithmChoicesGet();
};
if ($@) {
    warn "Exception when calling PoolDatasetApi->poolDatasetEncryptionAlgorithmChoicesGet: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.PoolDatasetApi()

try: 
    api_instance.pool_dataset_encryption_algorithm_choices_get()
except ApiException as e:
    print("Exception when calling PoolDatasetApi->poolDatasetEncryptionAlgorithmChoicesGet: %s\n" % e)

Parameters

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


poolDatasetEncryptionSummaryPost

Retrieve summary of all encrypted roots under `id`. Keys/passphrase can be supplied to check if the keys are valid. It should be noted that there are 2 keys which show if a recursive unlock operation is done for `id`, which dataset will be unlocked and if not why it won't be unlocked. The keys namely are "unlock_successful" and "unlock_error". The former is a boolean value showing if unlock would succeed/fail. The latter is description why it failed if it failed. If a dataset is already unlocked, it will show up as true for "unlock_successful" regardless of what key user provided as the unlock keys in the output are to reflect what a real unlock operation would behave. If user is interested in seeing if a provided key is valid or not, then the key to look out for in the output is "valid_key" which based on what system has in database or if a user provided one, validates the key and sets a boolean value for the dataset. Example output: [ { "name": "vol", "key_format": "PASSPHRASE", "key_present_in_database": false, "valid_key": true, "locked": true, "unlock_error": null, "unlock_successful": true }, { "name": "vol/c1/d1", "key_format": "PASSPHRASE", "key_present_in_database": false, "valid_key": false, "locked": true, "unlock_error": "Provided key is invalid", "unlock_successful": false }, { "name": "vol/c", "key_format": "PASSPHRASE", "key_present_in_database": false, "valid_key": false, "locked": true, "unlock_error": "Key not provided", "unlock_successful": false }, { "name": "vol/c/d2", "key_format": "PASSPHRASE", "key_present_in_database": false, "valid_key": false, "locked": true, "unlock_error": "Child cannot be unlocked when parent "vol/c" is locked and provided key is invalid", "unlock_successful": false } ] A file can be uploaded to this end point. This end point is special, please refer to Jobs section in Websocket API documentation for details.


/pool/dataset/encryption_summary

Usage and SDK Samples

curl -X POST -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/pool/dataset/encryption_summary"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.PoolDatasetApi;

import java.io.File;
import java.util.*;

public class PoolDatasetApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        PoolDatasetApi apiInstance = new PoolDatasetApi();
        Pool_dataset_encryption_summary body = ; // Pool_dataset_encryption_summary | 
        try {
            apiInstance.poolDatasetEncryptionSummaryPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling PoolDatasetApi#poolDatasetEncryptionSummaryPost");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::PoolDatasetApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::PoolDatasetApi->new();
my $body = WWW::SwaggerClient::Object::Pool_dataset_encryption_summary->new(); # Pool_dataset_encryption_summary | 

eval { 
    $api_instance->poolDatasetEncryptionSummaryPost(body => $body);
};
if ($@) {
    warn "Exception when calling PoolDatasetApi->poolDatasetEncryptionSummaryPost: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.PoolDatasetApi()
body =  # Pool_dataset_encryption_summary |  (optional)

try: 
    api_instance.pool_dataset_encryption_summary_post(body=body)
except ApiException as e:
    print("Exception when calling PoolDatasetApi->poolDatasetEncryptionSummaryPost: %s\n" % e)

Parameters

Body parameters
Name Description
body

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


poolDatasetGet

Query Pool Datasets with `query-filters` and `query-options`. We provide two ways to retrieve datasets. The first is a flat structure (default), where all datasets in the system are returned as separate objects which contain all data there is for their children. This retrieval type is slightly slower because of duplicates in each object. The second type is hierarchical, where only top level datasets are returned in the list. They contain all the children in the `children` key. This retrieval type is slightly faster. These options are controlled by the `query-options.extra.flat` attribute (default true).


/pool/dataset

Usage and SDK Samples

curl -X GET -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/pool/dataset?limit=&offset=&count=&sort="
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.PoolDatasetApi;

import java.io.File;
import java.util.*;

public class PoolDatasetApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        PoolDatasetApi apiInstance = new PoolDatasetApi();
        Integer limit = 56; // Integer | 
        Integer offset = 56; // Integer | 
        Boolean count = true; // Boolean | 
        String sort = sort_example; // String | 
        try {
            apiInstance.poolDatasetGet(limit, offset, count, sort);
        } catch (ApiException e) {
            System.err.println("Exception when calling PoolDatasetApi#poolDatasetGet");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::PoolDatasetApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::PoolDatasetApi->new();
my $limit = 56; # Integer | 
my $offset = 56; # Integer | 
my $count = true; # Boolean | 
my $sort = sort_example; # String | 

eval { 
    $api_instance->poolDatasetGet(limit => $limit, offset => $offset, count => $count, sort => $sort);
};
if ($@) {
    warn "Exception when calling PoolDatasetApi->poolDatasetGet: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.PoolDatasetApi()
limit = 56 # Integer |  (optional)
offset = 56 # Integer |  (optional)
count = true # Boolean |  (optional)
sort = sort_example # String |  (optional)

try: 
    api_instance.pool_dataset_get(limit=limit, offset=offset, count=count, sort=sort)
except ApiException as e:
    print("Exception when calling PoolDatasetApi->poolDatasetGet: %s\n" % e)

Parameters

Query parameters
Name Description
limit
Integer
offset
Integer
count
Boolean
sort
String

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


poolDatasetIdIdAttachmentsPost

Return a list of services dependent of this dataset. Responsible for telling the user whether there is a related share, asking for confirmation. Example return value: [ { "type": "NFS Share", "service": "nfs", "attachments": ["/mnt/tank/work"] } ]


/pool/dataset/id/{id}/attachments

Usage and SDK Samples

curl -X POST -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/pool/dataset/id/{id}/attachments"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.PoolDatasetApi;

import java.io.File;
import java.util.*;

public class PoolDatasetApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        PoolDatasetApi apiInstance = new PoolDatasetApi();
        String id = id_example; // String | 
        Pool_dataset_attachments body = ; // Pool_dataset_attachments | 
        try {
            apiInstance.poolDatasetIdIdAttachmentsPost(id, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling PoolDatasetApi#poolDatasetIdIdAttachmentsPost");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::PoolDatasetApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::PoolDatasetApi->new();
my $id = id_example; # String | 
my $body = WWW::SwaggerClient::Object::Pool_dataset_attachments->new(); # Pool_dataset_attachments | 

eval { 
    $api_instance->poolDatasetIdIdAttachmentsPost(id => $id, body => $body);
};
if ($@) {
    warn "Exception when calling PoolDatasetApi->poolDatasetIdIdAttachmentsPost: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.PoolDatasetApi()
id = id_example # String | 
body =  # Pool_dataset_attachments |  (optional)

try: 
    api_instance.pool_dataset_id_id_attachments_post(id, body=body)
except ApiException as e:
    print("Exception when calling PoolDatasetApi->poolDatasetIdIdAttachmentsPost: %s\n" % e)

Parameters

Path parameters
Name Description
id*
String
Required
Body parameters
Name Description
body

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


poolDatasetIdIdDelete

Delete dataset/zvol `id`. `recursive` will also delete/destroy all children datasets. `force` will force delete busy datasets.


/pool/dataset/id/{id}

Usage and SDK Samples

curl -X DELETE -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/pool/dataset/id/{id}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.PoolDatasetApi;

import java.io.File;
import java.util.*;

public class PoolDatasetApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        PoolDatasetApi apiInstance = new PoolDatasetApi();
        String id = id_example; // String | 
        Pool_dataset_delete_1 body = ; // Pool_dataset_delete_1 | 
        try {
            apiInstance.poolDatasetIdIdDelete(id, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling PoolDatasetApi#poolDatasetIdIdDelete");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::PoolDatasetApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::PoolDatasetApi->new();
my $id = id_example; # String | 
my $body = WWW::SwaggerClient::Object::Pool_dataset_delete_1->new(); # Pool_dataset_delete_1 | 

eval { 
    $api_instance->poolDatasetIdIdDelete(id => $id, body => $body);
};
if ($@) {
    warn "Exception when calling PoolDatasetApi->poolDatasetIdIdDelete: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.PoolDatasetApi()
id = id_example # String | 
body =  # Pool_dataset_delete_1 |  (optional)

try: 
    api_instance.pool_dataset_id_id_delete(id, body=body)
except ApiException as e:
    print("Exception when calling PoolDatasetApi->poolDatasetIdIdDelete: %s\n" % e)

Parameters

Path parameters
Name Description
id*
String
Required
Body parameters
Name Description
body

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


poolDatasetIdIdGet

Query Pool Datasets with `query-filters` and `query-options`. We provide two ways to retrieve datasets. The first is a flat structure (default), where all datasets in the system are returned as separate objects which contain all data there is for their children. This retrieval type is slightly slower because of duplicates in each object. The second type is hierarchical, where only top level datasets are returned in the list. They contain all the children in the `children` key. This retrieval type is slightly faster. These options are controlled by the `query-options.extra.flat` attribute (default true).


/pool/dataset/id/{id}

Usage and SDK Samples

curl -X GET -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/pool/dataset/id/{id}?limit=&offset=&count=&sort="
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.PoolDatasetApi;

import java.io.File;
import java.util.*;

public class PoolDatasetApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        PoolDatasetApi apiInstance = new PoolDatasetApi();
        array[null] id = ; // array[null] | 
        Integer limit = 56; // Integer | 
        Integer offset = 56; // Integer | 
        Boolean count = true; // Boolean | 
        String sort = sort_example; // String | 
        try {
            apiInstance.poolDatasetIdIdGet(id, limit, offset, count, sort);
        } catch (ApiException e) {
            System.err.println("Exception when calling PoolDatasetApi#poolDatasetIdIdGet");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::PoolDatasetApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::PoolDatasetApi->new();
my $id = []; # array[null] | 
my $limit = 56; # Integer | 
my $offset = 56; # Integer | 
my $count = true; # Boolean | 
my $sort = sort_example; # String | 

eval { 
    $api_instance->poolDatasetIdIdGet(id => $id, limit => $limit, offset => $offset, count => $count, sort => $sort);
};
if ($@) {
    warn "Exception when calling PoolDatasetApi->poolDatasetIdIdGet: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.PoolDatasetApi()
id =  # array[null] | 
limit = 56 # Integer |  (optional)
offset = 56 # Integer |  (optional)
count = true # Boolean |  (optional)
sort = sort_example # String |  (optional)

try: 
    api_instance.pool_dataset_id_id_get(id, limit=limit, offset=offset, count=count, sort=sort)
except ApiException as e:
    print("Exception when calling PoolDatasetApi->poolDatasetIdIdGet: %s\n" % e)

Parameters

Path parameters
Name Description
id*
array[null]
Required
Query parameters
Name Description
limit
Integer
offset
Integer
count
Boolean
sort
String

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


poolDatasetIdIdGetQuotaPost

Return a list of the specified `quota_type` of quotas on the ZFS dataset `ds`. Support `query-filters` and `query-options`. used_bytes and used_percentage may not instantly update as space is used. When quota_type is not DATASET, each quota entry has these fields: `id` - the uid or gid to which the quota applies. `name` - the user or group name to which the quota applies. Value is null if the id in the quota cannot be resolved to a user or group. This indicates that the user or group does not exist on the server. `quota` - the quota size in bytes. `used_bytes` - the amount of bytes the user has written to the dataset. A value of zero means unlimited. `used_percentage` - the percentage of the user or group quota consumed. `obj_quota` - the number of objects that may be owned by `id`. A value of zero means unlimited. 'obj_used` - the nubmer of objects currently owned by `id`. `obj_used_percent` - the percentage of the `obj_quota` currently used.


/pool/dataset/id/{id}/get_quota

Usage and SDK Samples

curl -X POST -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/pool/dataset/id/{id}/get_quota"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.PoolDatasetApi;

import java.io.File;
import java.util.*;

public class PoolDatasetApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        PoolDatasetApi apiInstance = new PoolDatasetApi();
        String id = id_example; // String | 
        Pool_dataset_get_quota body = ; // Pool_dataset_get_quota | 
        try {
            apiInstance.poolDatasetIdIdGetQuotaPost(id, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling PoolDatasetApi#poolDatasetIdIdGetQuotaPost");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::PoolDatasetApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::PoolDatasetApi->new();
my $id = id_example; # String | 
my $body = WWW::SwaggerClient::Object::Pool_dataset_get_quota->new(); # Pool_dataset_get_quota | 

eval { 
    $api_instance->poolDatasetIdIdGetQuotaPost(id => $id, body => $body);
};
if ($@) {
    warn "Exception when calling PoolDatasetApi->poolDatasetIdIdGetQuotaPost: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.PoolDatasetApi()
id = id_example # String | 
body =  # Pool_dataset_get_quota |  (optional)

try: 
    api_instance.pool_dataset_id_id_get_quota_post(id, body=body)
except ApiException as e:
    print("Exception when calling PoolDatasetApi->poolDatasetIdIdGetQuotaPost: %s\n" % e)

Parameters

Path parameters
Name Description
id*
String
Required
Body parameters
Name Description
body

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


poolDatasetIdIdPermissionPost

Set permissions for a dataset `id`. Permissions may be specified as either a posix `mode` or an nfsv4 `acl`. Setting mode will fail if the dataset has an existing nfsv4 acl. In this case, the option `stripacl` must be set to `True`.


/pool/dataset/id/{id}/permission

Usage and SDK Samples

curl -X POST -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/pool/dataset/id/{id}/permission"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.PoolDatasetApi;

import java.io.File;
import java.util.*;

public class PoolDatasetApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        PoolDatasetApi apiInstance = new PoolDatasetApi();
        String id = id_example; // String | 
        Pool_dataset_permission_1 body = ; // Pool_dataset_permission_1 | 
        try {
            apiInstance.poolDatasetIdIdPermissionPost(id, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling PoolDatasetApi#poolDatasetIdIdPermissionPost");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::PoolDatasetApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::PoolDatasetApi->new();
my $id = id_example; # String | 
my $body = WWW::SwaggerClient::Object::Pool_dataset_permission_1->new(); # Pool_dataset_permission_1 | 

eval { 
    $api_instance->poolDatasetIdIdPermissionPost(id => $id, body => $body);
};
if ($@) {
    warn "Exception when calling PoolDatasetApi->poolDatasetIdIdPermissionPost: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.PoolDatasetApi()
id = id_example # String | 
body =  # Pool_dataset_permission_1 |  (optional)

try: 
    api_instance.pool_dataset_id_id_permission_post(id, body=body)
except ApiException as e:
    print("Exception when calling PoolDatasetApi->poolDatasetIdIdPermissionPost: %s\n" % e)

Parameters

Path parameters
Name Description
id*
String
Required
Body parameters
Name Description
body

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


poolDatasetIdIdProcessesPost

Return a list of processes using this dataset. Example return value: [ { "pid": 2520, "name": "smbd", "service": "cifs" }, { "pid": 97778, "name": "minio", "cmdline": "/usr/local/bin/minio -C /usr/local/etc/minio server --address=0.0.0.0:9000 --quiet /mnt/tank/wk" } ]


/pool/dataset/id/{id}/processes

Usage and SDK Samples

curl -X POST -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/pool/dataset/id/{id}/processes"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.PoolDatasetApi;

import java.io.File;
import java.util.*;

public class PoolDatasetApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        PoolDatasetApi apiInstance = new PoolDatasetApi();
        String id = id_example; // String | 
        Pool_dataset_processes body = ; // Pool_dataset_processes | 
        try {
            apiInstance.poolDatasetIdIdProcessesPost(id, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling PoolDatasetApi#poolDatasetIdIdProcessesPost");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::PoolDatasetApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::PoolDatasetApi->new();
my $id = id_example; # String | 
my $body = WWW::SwaggerClient::Object::Pool_dataset_processes->new(); # Pool_dataset_processes | 

eval { 
    $api_instance->poolDatasetIdIdProcessesPost(id => $id, body => $body);
};
if ($@) {
    warn "Exception when calling PoolDatasetApi->poolDatasetIdIdProcessesPost: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.PoolDatasetApi()
id = id_example # String | 
body =  # Pool_dataset_processes |  (optional)

try: 
    api_instance.pool_dataset_id_id_processes_post(id, body=body)
except ApiException as e:
    print("Exception when calling PoolDatasetApi->poolDatasetIdIdProcessesPost: %s\n" % e)

Parameters

Path parameters
Name Description
id*
String
Required
Body parameters
Name Description
body

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


poolDatasetIdIdPromotePost

Promote the cloned dataset `id`.


/pool/dataset/id/{id}/promote

Usage and SDK Samples

curl -X POST -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/pool/dataset/id/{id}/promote"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.PoolDatasetApi;

import java.io.File;
import java.util.*;

public class PoolDatasetApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        PoolDatasetApi apiInstance = new PoolDatasetApi();
        String id = id_example; // String | 
        Pool_dataset_promote body = ; // Pool_dataset_promote | 
        try {
            apiInstance.poolDatasetIdIdPromotePost(id, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling PoolDatasetApi#poolDatasetIdIdPromotePost");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::PoolDatasetApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::PoolDatasetApi->new();
my $id = id_example; # String | 
my $body = WWW::SwaggerClient::Object::Pool_dataset_promote->new(); # Pool_dataset_promote | 

eval { 
    $api_instance->poolDatasetIdIdPromotePost(id => $id, body => $body);
};
if ($@) {
    warn "Exception when calling PoolDatasetApi->poolDatasetIdIdPromotePost: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.PoolDatasetApi()
id = id_example # String | 
body =  # Pool_dataset_promote |  (optional)

try: 
    api_instance.pool_dataset_id_id_promote_post(id, body=body)
except ApiException as e:
    print("Exception when calling PoolDatasetApi->poolDatasetIdIdPromotePost: %s\n" % e)

Parameters

Path parameters
Name Description
id*
String
Required
Body parameters
Name Description
body

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


poolDatasetIdIdPut

Updates a dataset/zvol `id`.


/pool/dataset/id/{id}

Usage and SDK Samples

curl -X PUT -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/pool/dataset/id/{id}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.PoolDatasetApi;

import java.io.File;
import java.util.*;

public class PoolDatasetApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        PoolDatasetApi apiInstance = new PoolDatasetApi();
        String id = id_example; // String | 
        Pool_dataset_update_1 body = ; // Pool_dataset_update_1 | 
        try {
            apiInstance.poolDatasetIdIdPut(id, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling PoolDatasetApi#poolDatasetIdIdPut");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::PoolDatasetApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::PoolDatasetApi->new();
my $id = id_example; # String | 
my $body = WWW::SwaggerClient::Object::Pool_dataset_update_1->new(); # Pool_dataset_update_1 | 

eval { 
    $api_instance->poolDatasetIdIdPut(id => $id, body => $body);
};
if ($@) {
    warn "Exception when calling PoolDatasetApi->poolDatasetIdIdPut: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.PoolDatasetApi()
id = id_example # String | 
body =  # Pool_dataset_update_1 |  (optional)

try: 
    api_instance.pool_dataset_id_id_put(id, body=body)
except ApiException as e:
    print("Exception when calling PoolDatasetApi->poolDatasetIdIdPut: %s\n" % e)

Parameters

Path parameters
Name Description
id*
String
Required
Body parameters
Name Description
body

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


poolDatasetIdIdSetQuotaPost

There are three over-arching types of quotas for ZFS datasets. 1) dataset quotas and refquotas. If a DATASET quota type is specified in this API call, then the API acts as a wrapper for `pool.dataset.update`. 2) User and group quotas. These limit the amount of disk space consumed by files that are owned by the specified users or groups. If the respective "object quota" type is specfied, then the quota limits the number of objects that may be owned by the specified user or group. 3) Project quotas. These limit the amount of disk space consumed by files that are owned by the specified project. Project quotas are not yet implemended. This API allows users to set multiple quotas simultaneously by submitting a list of quotas. The list may contain all supported quota types. `ds` the name of the target ZFS dataset. `quotas` specifies a list of `quota_entry` entries to apply to dataset. `quota_entry` entries have these required parameters: `quota_type`: specifies the type of quota to apply to the dataset. Possible values are USER, USEROBJ, GROUP, GROUPOBJ, and DATASET. USEROBJ and GROUPOBJ quotas limit the number of objects consumed by the specified user or group. `id`: the uid, gid, or name to which the quota applies. If quota_type is 'DATASET', then `id` must be either `QUOTA` or `REFQUOTA`. `quota_value`: the quota size in bytes. Setting a value of `0` removes the user or group quota.


/pool/dataset/id/{id}/set_quota

Usage and SDK Samples

curl -X POST -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/pool/dataset/id/{id}/set_quota"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.PoolDatasetApi;

import java.io.File;
import java.util.*;

public class PoolDatasetApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        PoolDatasetApi apiInstance = new PoolDatasetApi();
        String id = id_example; // String | 
        array[Object] body = ; // array[Object] | 
        try {
            apiInstance.poolDatasetIdIdSetQuotaPost(id, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling PoolDatasetApi#poolDatasetIdIdSetQuotaPost");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::PoolDatasetApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::PoolDatasetApi->new();
my $id = id_example; # String | 
my $body = [WWW::SwaggerClient::Object::array[Object]->new()]; # array[Object] | 

eval { 
    $api_instance->poolDatasetIdIdSetQuotaPost(id => $id, body => $body);
};
if ($@) {
    warn "Exception when calling PoolDatasetApi->poolDatasetIdIdSetQuotaPost: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.PoolDatasetApi()
id = id_example # String | 
body =  # array[Object] |  (optional)

try: 
    api_instance.pool_dataset_id_id_set_quota_post(id, body=body)
except ApiException as e:
    print("Exception when calling PoolDatasetApi->poolDatasetIdIdSetQuotaPost: %s\n" % e)

Parameters

Path parameters
Name Description
id*
String
Required
Body parameters
Name Description
body

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


poolDatasetInheritParentEncryptionPropertiesPost

Allows inheriting parent's encryption root discarding its current encryption settings. This can only be done where `id` has an encrypted parent and `id` itself is an encryption root.


/pool/dataset/inherit_parent_encryption_properties

Usage and SDK Samples

curl -X POST -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/pool/dataset/inherit_parent_encryption_properties"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.PoolDatasetApi;

import java.io.File;
import java.util.*;

public class PoolDatasetApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        PoolDatasetApi apiInstance = new PoolDatasetApi();
        String body = ; // String | 
        try {
            apiInstance.poolDatasetInheritParentEncryptionPropertiesPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling PoolDatasetApi#poolDatasetInheritParentEncryptionPropertiesPost");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::PoolDatasetApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::PoolDatasetApi->new();
my $body = WWW::SwaggerClient::Object::String->new(); # String | 

eval { 
    $api_instance->poolDatasetInheritParentEncryptionPropertiesPost(body => $body);
};
if ($@) {
    warn "Exception when calling PoolDatasetApi->poolDatasetInheritParentEncryptionPropertiesPost: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.PoolDatasetApi()
body =  # String |  (optional)

try: 
    api_instance.pool_dataset_inherit_parent_encryption_properties_post(body=body)
except ApiException as e:
    print("Exception when calling PoolDatasetApi->poolDatasetInheritParentEncryptionPropertiesPost: %s\n" % e)

Parameters

Body parameters
Name Description
body

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


poolDatasetLockPost

Locks `id` dataset. It will unmount the dataset and its children before locking.


/pool/dataset/lock

Usage and SDK Samples

curl -X POST -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/pool/dataset/lock"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.PoolDatasetApi;

import java.io.File;
import java.util.*;

public class PoolDatasetApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        PoolDatasetApi apiInstance = new PoolDatasetApi();
        Pool_dataset_lock body = ; // Pool_dataset_lock | 
        try {
            apiInstance.poolDatasetLockPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling PoolDatasetApi#poolDatasetLockPost");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::PoolDatasetApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::PoolDatasetApi->new();
my $body = WWW::SwaggerClient::Object::Pool_dataset_lock->new(); # Pool_dataset_lock | 

eval { 
    $api_instance->poolDatasetLockPost(body => $body);
};
if ($@) {
    warn "Exception when calling PoolDatasetApi->poolDatasetLockPost: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.PoolDatasetApi()
body =  # Pool_dataset_lock |  (optional)

try: 
    api_instance.pool_dataset_lock_post(body=body)
except ApiException as e:
    print("Exception when calling PoolDatasetApi->poolDatasetLockPost: %s\n" % e)

Parameters

Body parameters
Name Description
body

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


poolDatasetPost

Creates a dataset/zvol. `volsize` is required for type=VOLUME and is supposed to be a multiple of the block size. `sparse` and `volblocksize` are only used for type=VOLUME. `encryption` when enabled will create an ZFS encrypted root dataset for `name` pool. There are 2 cases where ZFS encryption is not allowed for a dataset: 1) Pool in question is GELI encrypted. 2) If the parent dataset is encrypted with a passphrase and `name` is being created with a key for encrypting the dataset. `encryption_options` specifies configuration for encryption of dataset for `name` pool. `encryption_options.passphrase` must be specified if encryption for dataset is desired with a passphrase as a key. Otherwise a hex encoded key can be specified by providing `encryption_options.key`. `encryption_options.generate_key` when enabled automatically generates the key to be used for dataset encryption. It should be noted that keys are stored by the system for automatic locking/unlocking on import/export of encrypted datasets. If that is not desired, dataset should be created with a passphrase as a key.


/pool/dataset

Usage and SDK Samples

curl -X POST -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/pool/dataset"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.PoolDatasetApi;

import java.io.File;
import java.util.*;

public class PoolDatasetApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        PoolDatasetApi apiInstance = new PoolDatasetApi();
        Pool_dataset_create_0 body = ; // Pool_dataset_create_0 | 
        try {
            apiInstance.poolDatasetPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling PoolDatasetApi#poolDatasetPost");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::PoolDatasetApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::PoolDatasetApi->new();
my $body = WWW::SwaggerClient::Object::Pool_dataset_create_0->new(); # Pool_dataset_create_0 | 

eval { 
    $api_instance->poolDatasetPost(body => $body);
};
if ($@) {
    warn "Exception when calling PoolDatasetApi->poolDatasetPost: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.PoolDatasetApi()
body =  # Pool_dataset_create_0 |  (optional)

try: 
    api_instance.pool_dataset_post(body=body)
except ApiException as e:
    print("Exception when calling PoolDatasetApi->poolDatasetPost: %s\n" % e)

Parameters

Body parameters
Name Description
body

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


poolDatasetRecommendedZvolBlocksizePost

Helper method to get recommended size for a new zvol (dataset of type VOLUME).


/pool/dataset/recommended_zvol_blocksize

Usage and SDK Samples

curl -X POST -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/pool/dataset/recommended_zvol_blocksize"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.PoolDatasetApi;

import java.io.File;
import java.util.*;

public class PoolDatasetApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        PoolDatasetApi apiInstance = new PoolDatasetApi();
        String body = ; // String | 
        try {
            apiInstance.poolDatasetRecommendedZvolBlocksizePost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling PoolDatasetApi#poolDatasetRecommendedZvolBlocksizePost");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::PoolDatasetApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::PoolDatasetApi->new();
my $body = WWW::SwaggerClient::Object::String->new(); # String | 

eval { 
    $api_instance->poolDatasetRecommendedZvolBlocksizePost(body => $body);
};
if ($@) {
    warn "Exception when calling PoolDatasetApi->poolDatasetRecommendedZvolBlocksizePost: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.PoolDatasetApi()
body =  # String |  (optional)

try: 
    api_instance.pool_dataset_recommended_zvol_blocksize_post(body=body)
except ApiException as e:
    print("Exception when calling PoolDatasetApi->poolDatasetRecommendedZvolBlocksizePost: %s\n" % e)

Parameters

Body parameters
Name Description
body

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


poolDatasetUnlockPost

Unlock `id` dataset. If `id` dataset is not encrypted an exception will be raised. There is one exception: when `id` is a root dataset and `unlock_options.recursive` is specified, encryption validation will not be performed for `id`. This allow unlocking encrypted children the `id` pool. For datasets which are encrypted with a passphrase, include the passphrase with `unlock_options.datasets`. Uploading a json file which contains encrypted dataset keys can be specified with `unlock_options.key_file`. The format is similar to that used for exporting encrypted dataset keys. A file can be uploaded to this end point. This end point is special, please refer to Jobs section in Websocket API documentation for details.


/pool/dataset/unlock

Usage and SDK Samples

curl -X POST -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/pool/dataset/unlock"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.PoolDatasetApi;

import java.io.File;
import java.util.*;

public class PoolDatasetApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        PoolDatasetApi apiInstance = new PoolDatasetApi();
        Pool_dataset_unlock body = ; // Pool_dataset_unlock | 
        try {
            apiInstance.poolDatasetUnlockPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling PoolDatasetApi#poolDatasetUnlockPost");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::PoolDatasetApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::PoolDatasetApi->new();
my $body = WWW::SwaggerClient::Object::Pool_dataset_unlock->new(); # Pool_dataset_unlock | 

eval { 
    $api_instance->poolDatasetUnlockPost(body => $body);
};
if ($@) {
    warn "Exception when calling PoolDatasetApi->poolDatasetUnlockPost: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.PoolDatasetApi()
body =  # Pool_dataset_unlock |  (optional)

try: 
    api_instance.pool_dataset_unlock_post(body=body)
except ApiException as e:
    print("Exception when calling PoolDatasetApi->poolDatasetUnlockPost: %s\n" % e)

Parameters

Body parameters
Name Description
body

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


PoolDatasetUserprop

poolDatasetUserpropGet

Query all user properties for ZFS datasets.


/pool/dataset/userprop

Usage and SDK Samples

curl -X GET -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/pool/dataset/userprop?limit=&offset=&count=&sort="
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.PoolDatasetUserpropApi;

import java.io.File;
import java.util.*;

public class PoolDatasetUserpropApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        PoolDatasetUserpropApi apiInstance = new PoolDatasetUserpropApi();
        Integer limit = 56; // Integer | 
        Integer offset = 56; // Integer | 
        Boolean count = true; // Boolean | 
        String sort = sort_example; // String | 
        try {
            apiInstance.poolDatasetUserpropGet(limit, offset, count, sort);
        } catch (ApiException e) {
            System.err.println("Exception when calling PoolDatasetUserpropApi#poolDatasetUserpropGet");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::PoolDatasetUserpropApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::PoolDatasetUserpropApi->new();
my $limit = 56; # Integer | 
my $offset = 56; # Integer | 
my $count = true; # Boolean | 
my $sort = sort_example; # String | 

eval { 
    $api_instance->poolDatasetUserpropGet(limit => $limit, offset => $offset, count => $count, sort => $sort);
};
if ($@) {
    warn "Exception when calling PoolDatasetUserpropApi->poolDatasetUserpropGet: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.PoolDatasetUserpropApi()
limit = 56 # Integer |  (optional)
offset = 56 # Integer |  (optional)
count = true # Boolean |  (optional)
sort = sort_example # String |  (optional)

try: 
    api_instance.pool_dataset_userprop_get(limit=limit, offset=offset, count=count, sort=sort)
except ApiException as e:
    print("Exception when calling PoolDatasetUserpropApi->poolDatasetUserpropGet: %s\n" % e)

Parameters

Query parameters
Name Description
limit
Integer
offset
Integer
count
Boolean
sort
String

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


poolDatasetUserpropIdIdDelete

Delete user property `dataset_user_prop_delete.name` for `id` dataset.


/pool/dataset/userprop/id/{id}

Usage and SDK Samples

curl -X DELETE -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/pool/dataset/userprop/id/{id}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.PoolDatasetUserpropApi;

import java.io.File;
import java.util.*;

public class PoolDatasetUserpropApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        PoolDatasetUserpropApi apiInstance = new PoolDatasetUserpropApi();
        String id = id_example; // String | 
        Pool_dataset_userprop_delete_1 body = ; // Pool_dataset_userprop_delete_1 | 
        try {
            apiInstance.poolDatasetUserpropIdIdDelete(id, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling PoolDatasetUserpropApi#poolDatasetUserpropIdIdDelete");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::PoolDatasetUserpropApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::PoolDatasetUserpropApi->new();
my $id = id_example; # String | 
my $body = WWW::SwaggerClient::Object::Pool_dataset_userprop_delete_1->new(); # Pool_dataset_userprop_delete_1 | 

eval { 
    $api_instance->poolDatasetUserpropIdIdDelete(id => $id, body => $body);
};
if ($@) {
    warn "Exception when calling PoolDatasetUserpropApi->poolDatasetUserpropIdIdDelete: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.PoolDatasetUserpropApi()
id = id_example # String | 
body =  # Pool_dataset_userprop_delete_1 |  (optional)

try: 
    api_instance.pool_dataset_userprop_id_id_delete(id, body=body)
except ApiException as e:
    print("Exception when calling PoolDatasetUserpropApi->poolDatasetUserpropIdIdDelete: %s\n" % e)

Parameters

Path parameters
Name Description
id*
String
Required
Body parameters
Name Description
body

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


poolDatasetUserpropIdIdGet

Query all user properties for ZFS datasets.


/pool/dataset/userprop/id/{id}

Usage and SDK Samples

curl -X GET -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/pool/dataset/userprop/id/{id}?limit=&offset=&count=&sort="
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.PoolDatasetUserpropApi;

import java.io.File;
import java.util.*;

public class PoolDatasetUserpropApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        PoolDatasetUserpropApi apiInstance = new PoolDatasetUserpropApi();
        array[null] id = ; // array[null] | 
        Integer limit = 56; // Integer | 
        Integer offset = 56; // Integer | 
        Boolean count = true; // Boolean | 
        String sort = sort_example; // String | 
        try {
            apiInstance.poolDatasetUserpropIdIdGet(id, limit, offset, count, sort);
        } catch (ApiException e) {
            System.err.println("Exception when calling PoolDatasetUserpropApi#poolDatasetUserpropIdIdGet");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::PoolDatasetUserpropApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::PoolDatasetUserpropApi->new();
my $id = []; # array[null] | 
my $limit = 56; # Integer | 
my $offset = 56; # Integer | 
my $count = true; # Boolean | 
my $sort = sort_example; # String | 

eval { 
    $api_instance->poolDatasetUserpropIdIdGet(id => $id, limit => $limit, offset => $offset, count => $count, sort => $sort);
};
if ($@) {
    warn "Exception when calling PoolDatasetUserpropApi->poolDatasetUserpropIdIdGet: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.PoolDatasetUserpropApi()
id =  # array[null] | 
limit = 56 # Integer |  (optional)
offset = 56 # Integer |  (optional)
count = true # Boolean |  (optional)
sort = sort_example # String |  (optional)

try: 
    api_instance.pool_dataset_userprop_id_id_get(id, limit=limit, offset=offset, count=count, sort=sort)
except ApiException as e:
    print("Exception when calling PoolDatasetUserpropApi->poolDatasetUserpropIdIdGet: %s\n" % e)

Parameters

Path parameters
Name Description
id*
array[null]
Required
Query parameters
Name Description
limit
Integer
offset
Integer
count
Boolean
sort
String

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


poolDatasetUserpropIdIdPut

Update `dataset_user_prop_update.name` user property for `id` dataset.


/pool/dataset/userprop/id/{id}

Usage and SDK Samples

curl -X PUT -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/pool/dataset/userprop/id/{id}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.PoolDatasetUserpropApi;

import java.io.File;
import java.util.*;

public class PoolDatasetUserpropApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        PoolDatasetUserpropApi apiInstance = new PoolDatasetUserpropApi();
        String id = id_example; // String | 
        Pool_dataset_userprop_update_1 body = ; // Pool_dataset_userprop_update_1 | 
        try {
            apiInstance.poolDatasetUserpropIdIdPut(id, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling PoolDatasetUserpropApi#poolDatasetUserpropIdIdPut");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::PoolDatasetUserpropApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::PoolDatasetUserpropApi->new();
my $id = id_example; # String | 
my $body = WWW::SwaggerClient::Object::Pool_dataset_userprop_update_1->new(); # Pool_dataset_userprop_update_1 | 

eval { 
    $api_instance->poolDatasetUserpropIdIdPut(id => $id, body => $body);
};
if ($@) {
    warn "Exception when calling PoolDatasetUserpropApi->poolDatasetUserpropIdIdPut: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.PoolDatasetUserpropApi()
id = id_example # String | 
body =  # Pool_dataset_userprop_update_1 |  (optional)

try: 
    api_instance.pool_dataset_userprop_id_id_put(id, body=body)
except ApiException as e:
    print("Exception when calling PoolDatasetUserpropApi->poolDatasetUserpropIdIdPut: %s\n" % e)

Parameters

Path parameters
Name Description
id*
String
Required
Body parameters
Name Description
body

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


poolDatasetUserpropPost

Create a user property for a given `id` dataset.


/pool/dataset/userprop

Usage and SDK Samples

curl -X POST -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/pool/dataset/userprop"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.PoolDatasetUserpropApi;

import java.io.File;
import java.util.*;

public class PoolDatasetUserpropApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        PoolDatasetUserpropApi apiInstance = new PoolDatasetUserpropApi();
        Pool_dataset_userprop_create_0 body = ; // Pool_dataset_userprop_create_0 | 
        try {
            apiInstance.poolDatasetUserpropPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling PoolDatasetUserpropApi#poolDatasetUserpropPost");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::PoolDatasetUserpropApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::PoolDatasetUserpropApi->new();
my $body = WWW::SwaggerClient::Object::Pool_dataset_userprop_create_0->new(); # Pool_dataset_userprop_create_0 | 

eval { 
    $api_instance->poolDatasetUserpropPost(body => $body);
};
if ($@) {
    warn "Exception when calling PoolDatasetUserpropApi->poolDatasetUserpropPost: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.PoolDatasetUserpropApi()
body =  # Pool_dataset_userprop_create_0 |  (optional)

try: 
    api_instance.pool_dataset_userprop_post(body=body)
except ApiException as e:
    print("Exception when calling PoolDatasetUserpropApi->poolDatasetUserpropPost: %s\n" % e)

Parameters

Body parameters
Name Description
body

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


PoolResilver

poolResilverGet


/pool/resilver

Usage and SDK Samples

curl -X GET -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/pool/resilver"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.PoolResilverApi;

import java.io.File;
import java.util.*;

public class PoolResilverApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        PoolResilverApi apiInstance = new PoolResilverApi();
        try {
            apiInstance.poolResilverGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling PoolResilverApi#poolResilverGet");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::PoolResilverApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::PoolResilverApi->new();

eval { 
    $api_instance->poolResilverGet();
};
if ($@) {
    warn "Exception when calling PoolResilverApi->poolResilverGet: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.PoolResilverApi()

try: 
    api_instance.pool_resilver_get()
except ApiException as e:
    print("Exception when calling PoolResilverApi->poolResilverGet: %s\n" % e)

Parameters

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


poolResilverPut

Configure Pool Resilver Priority. If `begin` time is greater than `end` time it means it will rollover the day, e.g. begin = "19:00", end = "05:00" will increase pool resilver priority from 19:00 of one day until 05:00 of the next day. `weekday` follows crontab(5) values 0-7 (0 or 7 is Sun).


/pool/resilver

Usage and SDK Samples

curl -X PUT -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/pool/resilver"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.PoolResilverApi;

import java.io.File;
import java.util.*;

public class PoolResilverApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        PoolResilverApi apiInstance = new PoolResilverApi();
        Pool_resilver_update_0 body = ; // Pool_resilver_update_0 | 
        try {
            apiInstance.poolResilverPut(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling PoolResilverApi#poolResilverPut");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::PoolResilverApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::PoolResilverApi->new();
my $body = WWW::SwaggerClient::Object::Pool_resilver_update_0->new(); # Pool_resilver_update_0 | 

eval { 
    $api_instance->poolResilverPut(body => $body);
};
if ($@) {
    warn "Exception when calling PoolResilverApi->poolResilverPut: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.PoolResilverApi()
body =  # Pool_resilver_update_0 |  (optional)

try: 
    api_instance.pool_resilver_put(body=body)
except ApiException as e:
    print("Exception when calling PoolResilverApi->poolResilverPut: %s\n" % e)

Parameters

Body parameters
Name Description
body

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


PoolScrub

poolScrubGet


/pool/scrub

Usage and SDK Samples

curl -X GET -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/pool/scrub?limit=&offset=&count=&sort="
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.PoolScrubApi;

import java.io.File;
import java.util.*;

public class PoolScrubApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        PoolScrubApi apiInstance = new PoolScrubApi();
        Integer limit = 56; // Integer | 
        Integer offset = 56; // Integer | 
        Boolean count = true; // Boolean | 
        String sort = sort_example; // String | 
        try {
            apiInstance.poolScrubGet(limit, offset, count, sort);
        } catch (ApiException e) {
            System.err.println("Exception when calling PoolScrubApi#poolScrubGet");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::PoolScrubApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::PoolScrubApi->new();
my $limit = 56; # Integer | 
my $offset = 56; # Integer | 
my $count = true; # Boolean | 
my $sort = sort_example; # String | 

eval { 
    $api_instance->poolScrubGet(limit => $limit, offset => $offset, count => $count, sort => $sort);
};
if ($@) {
    warn "Exception when calling PoolScrubApi->poolScrubGet: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.PoolScrubApi()
limit = 56 # Integer |  (optional)
offset = 56 # Integer |  (optional)
count = true # Boolean |  (optional)
sort = sort_example # String |  (optional)

try: 
    api_instance.pool_scrub_get(limit=limit, offset=offset, count=count, sort=sort)
except ApiException as e:
    print("Exception when calling PoolScrubApi->poolScrubGet: %s\n" % e)

Parameters

Query parameters
Name Description
limit
Integer
offset
Integer
count
Boolean
sort
String

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


poolScrubIdIdDelete

Delete scrub task of `id`.


/pool/scrub/id/{id}

Usage and SDK Samples

curl -X DELETE -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/pool/scrub/id/{id}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.PoolScrubApi;

import java.io.File;
import java.util.*;

public class PoolScrubApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        PoolScrubApi apiInstance = new PoolScrubApi();
        Integer id = 56; // Integer | 
        try {
            apiInstance.poolScrubIdIdDelete(id);
        } catch (ApiException e) {
            System.err.println("Exception when calling PoolScrubApi#poolScrubIdIdDelete");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::PoolScrubApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::PoolScrubApi->new();
my $id = 56; # Integer | 

eval { 
    $api_instance->poolScrubIdIdDelete(id => $id);
};
if ($@) {
    warn "Exception when calling PoolScrubApi->poolScrubIdIdDelete: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.PoolScrubApi()
id = 56 # Integer | 

try: 
    api_instance.pool_scrub_id_id_delete(id)
except ApiException as e:
    print("Exception when calling PoolScrubApi->poolScrubIdIdDelete: %s\n" % e)

Parameters

Path parameters
Name Description
id*
Integer
Required

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


poolScrubIdIdGet


/pool/scrub/id/{id}

Usage and SDK Samples

curl -X GET -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/pool/scrub/id/{id}?limit=&offset=&count=&sort="
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.PoolScrubApi;

import java.io.File;
import java.util.*;

public class PoolScrubApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        PoolScrubApi apiInstance = new PoolScrubApi();
        array[null] id = ; // array[null] | 
        Integer limit = 56; // Integer | 
        Integer offset = 56; // Integer | 
        Boolean count = true; // Boolean | 
        String sort = sort_example; // String | 
        try {
            apiInstance.poolScrubIdIdGet(id, limit, offset, count, sort);
        } catch (ApiException e) {
            System.err.println("Exception when calling PoolScrubApi#poolScrubIdIdGet");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::PoolScrubApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::PoolScrubApi->new();
my $id = []; # array[null] | 
my $limit = 56; # Integer | 
my $offset = 56; # Integer | 
my $count = true; # Boolean | 
my $sort = sort_example; # String | 

eval { 
    $api_instance->poolScrubIdIdGet(id => $id, limit => $limit, offset => $offset, count => $count, sort => $sort);
};
if ($@) {
    warn "Exception when calling PoolScrubApi->poolScrubIdIdGet: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.PoolScrubApi()
id =  # array[null] | 
limit = 56 # Integer |  (optional)
offset = 56 # Integer |  (optional)
count = true # Boolean |  (optional)
sort = sort_example # String |  (optional)

try: 
    api_instance.pool_scrub_id_id_get(id, limit=limit, offset=offset, count=count, sort=sort)
except ApiException as e:
    print("Exception when calling PoolScrubApi->poolScrubIdIdGet: %s\n" % e)

Parameters

Path parameters
Name Description
id*
array[null]
Required
Query parameters
Name Description
limit
Integer
offset
Integer
count
Boolean
sort
String

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


poolScrubIdIdPut

Update scrub task of `id`.


/pool/scrub/id/{id}

Usage and SDK Samples

curl -X PUT -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/pool/scrub/id/{id}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.PoolScrubApi;

import java.io.File;
import java.util.*;

public class PoolScrubApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        PoolScrubApi apiInstance = new PoolScrubApi();
        Integer id = 56; // Integer | 
        Pool_scrub_update_1 body = ; // Pool_scrub_update_1 | 
        try {
            apiInstance.poolScrubIdIdPut(id, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling PoolScrubApi#poolScrubIdIdPut");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::PoolScrubApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::PoolScrubApi->new();
my $id = 56; # Integer | 
my $body = WWW::SwaggerClient::Object::Pool_scrub_update_1->new(); # Pool_scrub_update_1 | 

eval { 
    $api_instance->poolScrubIdIdPut(id => $id, body => $body);
};
if ($@) {
    warn "Exception when calling PoolScrubApi->poolScrubIdIdPut: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.PoolScrubApi()
id = 56 # Integer | 
body =  # Pool_scrub_update_1 |  (optional)

try: 
    api_instance.pool_scrub_id_id_put(id, body=body)
except ApiException as e:
    print("Exception when calling PoolScrubApi->poolScrubIdIdPut: %s\n" % e)

Parameters

Path parameters
Name Description
id*
Integer
Required
Body parameters
Name Description
body

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


poolScrubPost

Create a scrub task for a pool. `threshold` refers to the minimum amount of time in days has to be passed before a scrub can run again.


/pool/scrub

Usage and SDK Samples

curl -X POST -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/pool/scrub"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.PoolScrubApi;

import java.io.File;
import java.util.*;

public class PoolScrubApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        PoolScrubApi apiInstance = new PoolScrubApi();
        Pool_scrub_create_0 body = ; // Pool_scrub_create_0 | 
        try {
            apiInstance.poolScrubPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling PoolScrubApi#poolScrubPost");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::PoolScrubApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::PoolScrubApi->new();
my $body = WWW::SwaggerClient::Object::Pool_scrub_create_0->new(); # Pool_scrub_create_0 | 

eval { 
    $api_instance->poolScrubPost(body => $body);
};
if ($@) {
    warn "Exception when calling PoolScrubApi->poolScrubPost: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.PoolScrubApi()
body =  # Pool_scrub_create_0 |  (optional)

try: 
    api_instance.pool_scrub_post(body=body)
except ApiException as e:
    print("Exception when calling PoolScrubApi->poolScrubPost: %s\n" % e)

Parameters

Body parameters
Name Description
body

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


poolScrubRunPost

Initiate a scrub of a pool `name` if last scrub was performed more than `threshold` days before.


/pool/scrub/run

Usage and SDK Samples

curl -X POST -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/pool/scrub/run"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.PoolScrubApi;

import java.io.File;
import java.util.*;

public class PoolScrubApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        PoolScrubApi apiInstance = new PoolScrubApi();
        Pool_scrub_run body = ; // Pool_scrub_run | 
        try {
            apiInstance.poolScrubRunPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling PoolScrubApi#poolScrubRunPost");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::PoolScrubApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::PoolScrubApi->new();
my $body = WWW::SwaggerClient::Object::Pool_scrub_run->new(); # Pool_scrub_run | 

eval { 
    $api_instance->poolScrubRunPost(body => $body);
};
if ($@) {
    warn "Exception when calling PoolScrubApi->poolScrubRunPost: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.PoolScrubApi()
body =  # Pool_scrub_run |  (optional)

try: 
    api_instance.pool_scrub_run_post(body=body)
except ApiException as e:
    print("Exception when calling PoolScrubApi->poolScrubRunPost: %s\n" % e)

Parameters

Body parameters
Name Description
body

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


PoolSnapshottask

poolSnapshottaskGet


/pool/snapshottask

Usage and SDK Samples

curl -X GET -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/pool/snapshottask?limit=&offset=&count=&sort="
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.PoolSnapshottaskApi;

import java.io.File;
import java.util.*;

public class PoolSnapshottaskApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        PoolSnapshottaskApi apiInstance = new PoolSnapshottaskApi();
        Integer limit = 56; // Integer | 
        Integer offset = 56; // Integer | 
        Boolean count = true; // Boolean | 
        String sort = sort_example; // String | 
        try {
            apiInstance.poolSnapshottaskGet(limit, offset, count, sort);
        } catch (ApiException e) {
            System.err.println("Exception when calling PoolSnapshottaskApi#poolSnapshottaskGet");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::PoolSnapshottaskApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::PoolSnapshottaskApi->new();
my $limit = 56; # Integer | 
my $offset = 56; # Integer | 
my $count = true; # Boolean | 
my $sort = sort_example; # String | 

eval { 
    $api_instance->poolSnapshottaskGet(limit => $limit, offset => $offset, count => $count, sort => $sort);
};
if ($@) {
    warn "Exception when calling PoolSnapshottaskApi->poolSnapshottaskGet: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.PoolSnapshottaskApi()
limit = 56 # Integer |  (optional)
offset = 56 # Integer |  (optional)
count = true # Boolean |  (optional)
sort = sort_example # String |  (optional)

try: 
    api_instance.pool_snapshottask_get(limit=limit, offset=offset, count=count, sort=sort)
except ApiException as e:
    print("Exception when calling PoolSnapshottaskApi->poolSnapshottaskGet: %s\n" % e)

Parameters

Query parameters
Name Description
limit
Integer
offset
Integer
count
Boolean
sort
String

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


poolSnapshottaskIdIdDelete

Delete a Periodic Snapshot Task with specific `id`


/pool/snapshottask/id/{id}

Usage and SDK Samples

curl -X DELETE -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/pool/snapshottask/id/{id}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.PoolSnapshottaskApi;

import java.io.File;
import java.util.*;

public class PoolSnapshottaskApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        PoolSnapshottaskApi apiInstance = new PoolSnapshottaskApi();
        Integer id = 56; // Integer | 
        try {
            apiInstance.poolSnapshottaskIdIdDelete(id);
        } catch (ApiException e) {
            System.err.println("Exception when calling PoolSnapshottaskApi#poolSnapshottaskIdIdDelete");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::PoolSnapshottaskApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::PoolSnapshottaskApi->new();
my $id = 56; # Integer | 

eval { 
    $api_instance->poolSnapshottaskIdIdDelete(id => $id);
};
if ($@) {
    warn "Exception when calling PoolSnapshottaskApi->poolSnapshottaskIdIdDelete: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.PoolSnapshottaskApi()
id = 56 # Integer | 

try: 
    api_instance.pool_snapshottask_id_id_delete(id)
except ApiException as e:
    print("Exception when calling PoolSnapshottaskApi->poolSnapshottaskIdIdDelete: %s\n" % e)

Parameters

Path parameters
Name Description
id*
Integer
Required

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


poolSnapshottaskIdIdGet


/pool/snapshottask/id/{id}

Usage and SDK Samples

curl -X GET -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/pool/snapshottask/id/{id}?limit=&offset=&count=&sort="
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.PoolSnapshottaskApi;

import java.io.File;
import java.util.*;

public class PoolSnapshottaskApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        PoolSnapshottaskApi apiInstance = new PoolSnapshottaskApi();
        array[null] id = ; // array[null] | 
        Integer limit = 56; // Integer | 
        Integer offset = 56; // Integer | 
        Boolean count = true; // Boolean | 
        String sort = sort_example; // String | 
        try {
            apiInstance.poolSnapshottaskIdIdGet(id, limit, offset, count, sort);
        } catch (ApiException e) {
            System.err.println("Exception when calling PoolSnapshottaskApi#poolSnapshottaskIdIdGet");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::PoolSnapshottaskApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::PoolSnapshottaskApi->new();
my $id = []; # array[null] | 
my $limit = 56; # Integer | 
my $offset = 56; # Integer | 
my $count = true; # Boolean | 
my $sort = sort_example; # String | 

eval { 
    $api_instance->poolSnapshottaskIdIdGet(id => $id, limit => $limit, offset => $offset, count => $count, sort => $sort);
};
if ($@) {
    warn "Exception when calling PoolSnapshottaskApi->poolSnapshottaskIdIdGet: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.PoolSnapshottaskApi()
id =  # array[null] | 
limit = 56 # Integer |  (optional)
offset = 56 # Integer |  (optional)
count = true # Boolean |  (optional)
sort = sort_example # String |  (optional)

try: 
    api_instance.pool_snapshottask_id_id_get(id, limit=limit, offset=offset, count=count, sort=sort)
except ApiException as e:
    print("Exception when calling PoolSnapshottaskApi->poolSnapshottaskIdIdGet: %s\n" % e)

Parameters

Path parameters
Name Description
id*
array[null]
Required
Query parameters
Name Description
limit
Integer
offset
Integer
count
Boolean
sort
String

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


poolSnapshottaskIdIdPut

Update a Periodic Snapshot Task with specific `id` See the documentation for `create` method for information on payload contents


/pool/snapshottask/id/{id}

Usage and SDK Samples

curl -X PUT -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/pool/snapshottask/id/{id}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.PoolSnapshottaskApi;

import java.io.File;
import java.util.*;

public class PoolSnapshottaskApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        PoolSnapshottaskApi apiInstance = new PoolSnapshottaskApi();
        Integer id = 56; // Integer | 
        Pool_snapshottask_update_1 body = ; // Pool_snapshottask_update_1 | 
        try {
            apiInstance.poolSnapshottaskIdIdPut(id, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling PoolSnapshottaskApi#poolSnapshottaskIdIdPut");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::PoolSnapshottaskApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::PoolSnapshottaskApi->new();
my $id = 56; # Integer | 
my $body = WWW::SwaggerClient::Object::Pool_snapshottask_update_1->new(); # Pool_snapshottask_update_1 | 

eval { 
    $api_instance->poolSnapshottaskIdIdPut(id => $id, body => $body);
};
if ($@) {
    warn "Exception when calling PoolSnapshottaskApi->poolSnapshottaskIdIdPut: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.PoolSnapshottaskApi()
id = 56 # Integer | 
body =  # Pool_snapshottask_update_1 |  (optional)

try: 
    api_instance.pool_snapshottask_id_id_put(id, body=body)
except ApiException as e:
    print("Exception when calling PoolSnapshottaskApi->poolSnapshottaskIdIdPut: %s\n" % e)

Parameters

Path parameters
Name Description
id*
Integer
Required
Body parameters
Name Description
body

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


poolSnapshottaskIdIdRunPost

Execute a Periodic Snapshot Task of `id`.


/pool/snapshottask/id/{id}/run

Usage and SDK Samples

curl -X POST -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/pool/snapshottask/id/{id}/run"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.PoolSnapshottaskApi;

import java.io.File;
import java.util.*;

public class PoolSnapshottaskApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        PoolSnapshottaskApi apiInstance = new PoolSnapshottaskApi();
        Integer id = 56; // Integer | 
        Pool_snapshottask_run body = ; // Pool_snapshottask_run | 
        try {
            apiInstance.poolSnapshottaskIdIdRunPost(id, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling PoolSnapshottaskApi#poolSnapshottaskIdIdRunPost");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::PoolSnapshottaskApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::PoolSnapshottaskApi->new();
my $id = 56; # Integer | 
my $body = WWW::SwaggerClient::Object::Pool_snapshottask_run->new(); # Pool_snapshottask_run | 

eval { 
    $api_instance->poolSnapshottaskIdIdRunPost(id => $id, body => $body);
};
if ($@) {
    warn "Exception when calling PoolSnapshottaskApi->poolSnapshottaskIdIdRunPost: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.PoolSnapshottaskApi()
id = 56 # Integer | 
body =  # Pool_snapshottask_run |  (optional)

try: 
    api_instance.pool_snapshottask_id_id_run_post(id, body=body)
except ApiException as e:
    print("Exception when calling PoolSnapshottaskApi->poolSnapshottaskIdIdRunPost: %s\n" % e)

Parameters

Path parameters
Name Description
id*
Integer
Required
Body parameters
Name Description
body

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


poolSnapshottaskPost

Create a Periodic Snapshot Task Create a Periodic Snapshot Task that will take snapshots of specified `dataset` at specified `schedule`. Recursive snapshots can be created if `recursive` flag is enabled. You can `exclude` specific child datasets from snapshot. Snapshots will be automatically destroyed after a certain amount of time, specified by `lifetime_value` and `lifetime_unit`. Snapshots will be named according to `naming_schema` which is a `strftime`-like template for snapshot name and must contain `%Y`, `%m`, `%d`, `%H` and `%M`.


/pool/snapshottask

Usage and SDK Samples

curl -X POST -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/pool/snapshottask"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.PoolSnapshottaskApi;

import java.io.File;
import java.util.*;

public class PoolSnapshottaskApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        PoolSnapshottaskApi apiInstance = new PoolSnapshottaskApi();
        Pool_snapshottask_create_0 body = ; // Pool_snapshottask_create_0 | 
        try {
            apiInstance.poolSnapshottaskPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling PoolSnapshottaskApi#poolSnapshottaskPost");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::PoolSnapshottaskApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::PoolSnapshottaskApi->new();
my $body = WWW::SwaggerClient::Object::Pool_snapshottask_create_0->new(); # Pool_snapshottask_create_0 | 

eval { 
    $api_instance->poolSnapshottaskPost(body => $body);
};
if ($@) {
    warn "Exception when calling PoolSnapshottaskApi->poolSnapshottaskPost: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.PoolSnapshottaskApi()
body =  # Pool_snapshottask_create_0 |  (optional)

try: 
    api_instance.pool_snapshottask_post(body=body)
except ApiException as e:
    print("Exception when calling PoolSnapshottaskApi->poolSnapshottaskPost: %s\n" % e)

Parameters

Body parameters
Name Description
body

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


Replication

replicationCountEligibleManualSnapshotsPost

Count how many existing snapshots of `dataset` match `naming_schema`.


/replication/count_eligible_manual_snapshots

Usage and SDK Samples

curl -X POST -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/replication/count_eligible_manual_snapshots"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.ReplicationApi;

import java.io.File;
import java.util.*;

public class ReplicationApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        ReplicationApi apiInstance = new ReplicationApi();
        Replication_count_eligible_manual_snapshots body = ; // Replication_count_eligible_manual_snapshots | 
        try {
            apiInstance.replicationCountEligibleManualSnapshotsPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling ReplicationApi#replicationCountEligibleManualSnapshotsPost");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::ReplicationApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::ReplicationApi->new();
my $body = WWW::SwaggerClient::Object::Replication_count_eligible_manual_snapshots->new(); # Replication_count_eligible_manual_snapshots | 

eval { 
    $api_instance->replicationCountEligibleManualSnapshotsPost(body => $body);
};
if ($@) {
    warn "Exception when calling ReplicationApi->replicationCountEligibleManualSnapshotsPost: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.ReplicationApi()
body =  # Replication_count_eligible_manual_snapshots |  (optional)

try: 
    api_instance.replication_count_eligible_manual_snapshots_post(body=body)
except ApiException as e:
    print("Exception when calling ReplicationApi->replicationCountEligibleManualSnapshotsPost: %s\n" % e)

Parameters

Body parameters
Name Description
body

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


replicationCreateDatasetPost

Creates dataset on remote side Accepts `dataset` name, `transport` and SSH credentials ID (for non-local transport)


/replication/create_dataset

Usage and SDK Samples

curl -X POST -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/replication/create_dataset"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.ReplicationApi;

import java.io.File;
import java.util.*;

public class ReplicationApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        ReplicationApi apiInstance = new ReplicationApi();
        Replication_create_dataset body = ; // Replication_create_dataset | 
        try {
            apiInstance.replicationCreateDatasetPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling ReplicationApi#replicationCreateDatasetPost");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::ReplicationApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::ReplicationApi->new();
my $body = WWW::SwaggerClient::Object::Replication_create_dataset->new(); # Replication_create_dataset | 

eval { 
    $api_instance->replicationCreateDatasetPost(body => $body);
};
if ($@) {
    warn "Exception when calling ReplicationApi->replicationCreateDatasetPost: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.ReplicationApi()
body =  # Replication_create_dataset |  (optional)

try: 
    api_instance.replication_create_dataset_post(body=body)
except ApiException as e:
    print("Exception when calling ReplicationApi->replicationCreateDatasetPost: %s\n" % e)

Parameters

Body parameters
Name Description
body

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


replicationGet


/replication

Usage and SDK Samples

curl -X GET -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/replication?limit=&offset=&count=&sort="
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.ReplicationApi;

import java.io.File;
import java.util.*;

public class ReplicationApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        ReplicationApi apiInstance = new ReplicationApi();
        Integer limit = 56; // Integer | 
        Integer offset = 56; // Integer | 
        Boolean count = true; // Boolean | 
        String sort = sort_example; // String | 
        try {
            apiInstance.replicationGet(limit, offset, count, sort);
        } catch (ApiException e) {
            System.err.println("Exception when calling ReplicationApi#replicationGet");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::ReplicationApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::ReplicationApi->new();
my $limit = 56; # Integer | 
my $offset = 56; # Integer | 
my $count = true; # Boolean | 
my $sort = sort_example; # String | 

eval { 
    $api_instance->replicationGet(limit => $limit, offset => $offset, count => $count, sort => $sort);
};
if ($@) {
    warn "Exception when calling ReplicationApi->replicationGet: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.ReplicationApi()
limit = 56 # Integer |  (optional)
offset = 56 # Integer |  (optional)
count = true # Boolean |  (optional)
sort = sort_example # String |  (optional)

try: 
    api_instance.replication_get(limit=limit, offset=offset, count=count, sort=sort)
except ApiException as e:
    print("Exception when calling ReplicationApi->replicationGet: %s\n" % e)

Parameters

Query parameters
Name Description
limit
Integer
offset
Integer
count
Boolean
sort
String

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


replicationIdIdDelete

Delete a Replication Task with specific `id`


/replication/id/{id}

Usage and SDK Samples

curl -X DELETE -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/replication/id/{id}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.ReplicationApi;

import java.io.File;
import java.util.*;

public class ReplicationApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        ReplicationApi apiInstance = new ReplicationApi();
        Integer id = 56; // Integer | 
        try {
            apiInstance.replicationIdIdDelete(id);
        } catch (ApiException e) {
            System.err.println("Exception when calling ReplicationApi#replicationIdIdDelete");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::ReplicationApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::ReplicationApi->new();
my $id = 56; # Integer | 

eval { 
    $api_instance->replicationIdIdDelete(id => $id);
};
if ($@) {
    warn "Exception when calling ReplicationApi->replicationIdIdDelete: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.ReplicationApi()
id = 56 # Integer | 

try: 
    api_instance.replication_id_id_delete(id)
except ApiException as e:
    print("Exception when calling ReplicationApi->replicationIdIdDelete: %s\n" % e)

Parameters

Path parameters
Name Description
id*
Integer
Required

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


replicationIdIdGet


/replication/id/{id}

Usage and SDK Samples

curl -X GET -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/replication/id/{id}?limit=&offset=&count=&sort="
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.ReplicationApi;

import java.io.File;
import java.util.*;

public class ReplicationApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        ReplicationApi apiInstance = new ReplicationApi();
        array[null] id = ; // array[null] | 
        Integer limit = 56; // Integer | 
        Integer offset = 56; // Integer | 
        Boolean count = true; // Boolean | 
        String sort = sort_example; // String | 
        try {
            apiInstance.replicationIdIdGet(id, limit, offset, count, sort);
        } catch (ApiException e) {
            System.err.println("Exception when calling ReplicationApi#replicationIdIdGet");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::ReplicationApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::ReplicationApi->new();
my $id = []; # array[null] | 
my $limit = 56; # Integer | 
my $offset = 56; # Integer | 
my $count = true; # Boolean | 
my $sort = sort_example; # String | 

eval { 
    $api_instance->replicationIdIdGet(id => $id, limit => $limit, offset => $offset, count => $count, sort => $sort);
};
if ($@) {
    warn "Exception when calling ReplicationApi->replicationIdIdGet: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.ReplicationApi()
id =  # array[null] | 
limit = 56 # Integer |  (optional)
offset = 56 # Integer |  (optional)
count = true # Boolean |  (optional)
sort = sort_example # String |  (optional)

try: 
    api_instance.replication_id_id_get(id, limit=limit, offset=offset, count=count, sort=sort)
except ApiException as e:
    print("Exception when calling ReplicationApi->replicationIdIdGet: %s\n" % e)

Parameters

Path parameters
Name Description
id*
array[null]
Required
Query parameters
Name Description
limit
Integer
offset
Integer
count
Boolean
sort
String

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


replicationIdIdPut

Update a Replication Task with specific `id` See the documentation for `create` method for information on payload contents


/replication/id/{id}

Usage and SDK Samples

curl -X PUT -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/replication/id/{id}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.ReplicationApi;

import java.io.File;
import java.util.*;

public class ReplicationApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        ReplicationApi apiInstance = new ReplicationApi();
        Integer id = 56; // Integer | 
        Replication_update_1 body = ; // Replication_update_1 | 
        try {
            apiInstance.replicationIdIdPut(id, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling ReplicationApi#replicationIdIdPut");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::ReplicationApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::ReplicationApi->new();
my $id = 56; # Integer | 
my $body = WWW::SwaggerClient::Object::Replication_update_1->new(); # Replication_update_1 | 

eval { 
    $api_instance->replicationIdIdPut(id => $id, body => $body);
};
if ($@) {
    warn "Exception when calling ReplicationApi->replicationIdIdPut: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.ReplicationApi()
id = 56 # Integer | 
body =  # Replication_update_1 |  (optional)

try: 
    api_instance.replication_id_id_put(id, body=body)
except ApiException as e:
    print("Exception when calling ReplicationApi->replicationIdIdPut: %s\n" % e)

Parameters

Path parameters
Name Description
id*
Integer
Required
Body parameters
Name Description
body

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


replicationIdIdRestorePost

Create the opposite of replication task `id` (PULL if it was PUSH and vice versa).


/replication/id/{id}/restore

Usage and SDK Samples

curl -X POST -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/replication/id/{id}/restore"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.ReplicationApi;

import java.io.File;
import java.util.*;

public class ReplicationApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        ReplicationApi apiInstance = new ReplicationApi();
        Integer id = 56; // Integer | 
        Replication_restore_1 body = ; // Replication_restore_1 | 
        try {
            apiInstance.replicationIdIdRestorePost(id, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling ReplicationApi#replicationIdIdRestorePost");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::ReplicationApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::ReplicationApi->new();
my $id = 56; # Integer | 
my $body = WWW::SwaggerClient::Object::Replication_restore_1->new(); # Replication_restore_1 | 

eval { 
    $api_instance->replicationIdIdRestorePost(id => $id, body => $body);
};
if ($@) {
    warn "Exception when calling ReplicationApi->replicationIdIdRestorePost: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.ReplicationApi()
id = 56 # Integer | 
body =  # Replication_restore_1 |  (optional)

try: 
    api_instance.replication_id_id_restore_post(id, body=body)
except ApiException as e:
    print("Exception when calling ReplicationApi->replicationIdIdRestorePost: %s\n" % e)

Parameters

Path parameters
Name Description
id*
Integer
Required
Body parameters
Name Description
body

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


replicationIdIdRunPost

Run Replication Task of `id`.


/replication/id/{id}/run

Usage and SDK Samples

curl -X POST -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/replication/id/{id}/run"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.ReplicationApi;

import java.io.File;
import java.util.*;

public class ReplicationApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        ReplicationApi apiInstance = new ReplicationApi();
        Integer id = 56; // Integer | 
        Replication_run body = ; // Replication_run | 
        try {
            apiInstance.replicationIdIdRunPost(id, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling ReplicationApi#replicationIdIdRunPost");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::ReplicationApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::ReplicationApi->new();
my $id = 56; # Integer | 
my $body = WWW::SwaggerClient::Object::Replication_run->new(); # Replication_run | 

eval { 
    $api_instance->replicationIdIdRunPost(id => $id, body => $body);
};
if ($@) {
    warn "Exception when calling ReplicationApi->replicationIdIdRunPost: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.ReplicationApi()
id = 56 # Integer | 
body =  # Replication_run |  (optional)

try: 
    api_instance.replication_id_id_run_post(id, body=body)
except ApiException as e:
    print("Exception when calling ReplicationApi->replicationIdIdRunPost: %s\n" % e)

Parameters

Path parameters
Name Description
id*
Integer
Required
Body parameters
Name Description
body

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


replicationListDatasetsPost

List datasets on remote side Accepts `transport` and SSH credentials ID (for non-local transport)


/replication/list_datasets

Usage and SDK Samples

curl -X POST -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/replication/list_datasets"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.ReplicationApi;

import java.io.File;
import java.util.*;

public class ReplicationApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        ReplicationApi apiInstance = new ReplicationApi();
        Replication_list_datasets body = ; // Replication_list_datasets | 
        try {
            apiInstance.replicationListDatasetsPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling ReplicationApi#replicationListDatasetsPost");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::ReplicationApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::ReplicationApi->new();
my $body = WWW::SwaggerClient::Object::Replication_list_datasets->new(); # Replication_list_datasets | 

eval { 
    $api_instance->replicationListDatasetsPost(body => $body);
};
if ($@) {
    warn "Exception when calling ReplicationApi->replicationListDatasetsPost: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.ReplicationApi()
body =  # Replication_list_datasets |  (optional)

try: 
    api_instance.replication_list_datasets_post(body=body)
except ApiException as e:
    print("Exception when calling ReplicationApi->replicationListDatasetsPost: %s\n" % e)

Parameters

Body parameters
Name Description
body

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


replicationListNamingSchemasGet

List all naming schemas used in periodic snapshot and replication tasks.


/replication/list_naming_schemas

Usage and SDK Samples

curl -X GET -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/replication/list_naming_schemas"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.ReplicationApi;

import java.io.File;
import java.util.*;

public class ReplicationApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        ReplicationApi apiInstance = new ReplicationApi();
        try {
            apiInstance.replicationListNamingSchemasGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling ReplicationApi#replicationListNamingSchemasGet");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::ReplicationApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::ReplicationApi->new();

eval { 
    $api_instance->replicationListNamingSchemasGet();
};
if ($@) {
    warn "Exception when calling ReplicationApi->replicationListNamingSchemasGet: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.ReplicationApi()

try: 
    api_instance.replication_list_naming_schemas_get()
except ApiException as e:
    print("Exception when calling ReplicationApi->replicationListNamingSchemasGet: %s\n" % e)

Parameters

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


replicationPost

Create a Replication Task Create a Replication Task that will push or pull ZFS snapshots to or from remote host.. * `name` specifies a name for replication task * `direction` specifies whether task will `PUSH` or `PULL` snapshots * `transport` is a method of snapshots transfer: * `SSH` transfers snapshots via SSH connection. This method is supported everywhere but does not achieve great performance `ssh_credentials` is a required field for this transport (Keychain Credential ID of type `SSH_CREDENTIALS`) * `SSH+NETCAT` uses unencrypted connection for data transfer. This can only be used in trusted networks and requires a port (specified by range from `netcat_active_side_port_min` to `netcat_active_side_port_max`) to be open on `netcat_active_side` `ssh_credentials` is also required for control connection * `LOCAL` replicates to or from localhost * `source_datasets` is a non-empty list of datasets to replicate snapshots from * `target_dataset` is a dataset to put snapshots into. It must exist on target side * `recursive` and `exclude` have the same meaning as for Periodic Snapshot Task * `properties` control whether we should send dataset properties along with snapshots * `periodic_snapshot_tasks` is a list of periodic snapshot task IDs that are sources of snapshots for this replication task. Only push replication tasks can be bound to periodic snapshot tasks. * `naming_schema` is a list of naming schemas for pull replication * `also_include_naming_schema` is a list of naming schemas for push replication * `auto` allows replication to run automatically on schedule or after bound periodic snapshot task * `schedule` is a schedule to run replication task. Only `auto` replication tasks without bound periodic snapshot tasks can have a schedule * `restrict_schedule` restricts when replication task with bound periodic snapshot tasks runs. For example, you can have periodic snapshot tasks that run every 15 minutes, but only run replication task every hour. * Enabling `only_matching_schedule` will only replicate snapshots that match `schedule` or `restrict_schedule` * `allow_from_scratch` will destroy all snapshots on target side and replicate everything from scratch if none of the snapshots on target side matches source snapshots * `readonly` controls destination datasets readonly property: * `SET` will set all destination datasets to readonly=on after finishing the replication * `REQUIRE` will require all existing destination datasets to have readonly=on property * `IGNORE` will avoid this kind of behavior * `hold_pending_snapshots` will prevent source snapshots from being deleted by retention of replication fails for some reason * `retention_policy` specifies how to delete old snapshots on target side: * `SOURCE` deletes snapshots that are absent on source side * `CUSTOM` deletes snapshots that are older than `lifetime_value` and `lifetime_unit` * `NONE` does not delete any snapshots * `compression` compresses SSH stream. Available only for SSH transport * `speed_limit` limits speed of SSH stream. Available only for SSH transport * `large_block`, `embed` and `compressed` are various ZFS stream flag documented in `man zfs send` * `retries` specifies number of retries before considering replication failed


/replication

Usage and SDK Samples

curl -X POST -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/replication"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.ReplicationApi;

import java.io.File;
import java.util.*;

public class ReplicationApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        ReplicationApi apiInstance = new ReplicationApi();
        Replication_create_0 body = ; // Replication_create_0 | 
        try {
            apiInstance.replicationPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling ReplicationApi#replicationPost");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::ReplicationApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::ReplicationApi->new();
my $body = WWW::SwaggerClient::Object::Replication_create_0->new(); # Replication_create_0 | 

eval { 
    $api_instance->replicationPost(body => $body);
};
if ($@) {
    warn "Exception when calling ReplicationApi->replicationPost: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.ReplicationApi()
body =  # Replication_create_0 |  (optional)

try: 
    api_instance.replication_post(body=body)
except ApiException as e:
    print("Exception when calling ReplicationApi->replicationPost: %s\n" % e)

Parameters

Body parameters
Name Description
body

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


replicationTargetUnmatchedSnapshotsPost

Check if target has any snapshots that do not exist on source.


/replication/target_unmatched_snapshots

Usage and SDK Samples

curl -X POST -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/replication/target_unmatched_snapshots"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.ReplicationApi;

import java.io.File;
import java.util.*;

public class ReplicationApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        ReplicationApi apiInstance = new ReplicationApi();
        Replication_target_unmatched_snapshots body = ; // Replication_target_unmatched_snapshots | 
        try {
            apiInstance.replicationTargetUnmatchedSnapshotsPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling ReplicationApi#replicationTargetUnmatchedSnapshotsPost");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::ReplicationApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::ReplicationApi->new();
my $body = WWW::SwaggerClient::Object::Replication_target_unmatched_snapshots->new(); # Replication_target_unmatched_snapshots | 

eval { 
    $api_instance->replicationTargetUnmatchedSnapshotsPost(body => $body);
};
if ($@) {
    warn "Exception when calling ReplicationApi->replicationTargetUnmatchedSnapshotsPost: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.ReplicationApi()
body =  # Replication_target_unmatched_snapshots |  (optional)

try: 
    api_instance.replication_target_unmatched_snapshots_post(body=body)
except ApiException as e:
    print("Exception when calling ReplicationApi->replicationTargetUnmatchedSnapshotsPost: %s\n" % e)

Parameters

Body parameters
Name Description
body

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


Reporting

reportingGet


/reporting

Usage and SDK Samples

curl -X GET -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/reporting"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.ReportingApi;

import java.io.File;
import java.util.*;

public class ReportingApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        ReportingApi apiInstance = new ReportingApi();
        try {
            apiInstance.reportingGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling ReportingApi#reportingGet");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::ReportingApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::ReportingApi->new();

eval { 
    $api_instance->reportingGet();
};
if ($@) {
    warn "Exception when calling ReportingApi->reportingGet: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.ReportingApi()

try: 
    api_instance.reporting_get()
except ApiException as e:
    print("Exception when calling ReportingApi->reportingGet: %s\n" % e)

Parameters

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


reportingGetDataPost

Get reporting data for given graphs. List of possible graphs can be retrieved using `reporting.graphs` call. For the time period of the graph either `unit` and `page` OR `start` and `end` should be used, not both. `aggregate` will return aggregate available data for each graph (e.g. min, max, mean).


/reporting/get_data

Usage and SDK Samples

curl -X POST -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/reporting/get_data"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.ReportingApi;

import java.io.File;
import java.util.*;

public class ReportingApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        ReportingApi apiInstance = new ReportingApi();
        Reporting_get_data body = ; // Reporting_get_data | 
        try {
            apiInstance.reportingGetDataPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling ReportingApi#reportingGetDataPost");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::ReportingApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::ReportingApi->new();
my $body = WWW::SwaggerClient::Object::Reporting_get_data->new(); # Reporting_get_data | 

eval { 
    $api_instance->reportingGetDataPost(body => $body);
};
if ($@) {
    warn "Exception when calling ReportingApi->reportingGetDataPost: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.ReportingApi()
body =  # Reporting_get_data |  (optional)

try: 
    api_instance.reporting_get_data_post(body=body)
except ApiException as e:
    print("Exception when calling ReportingApi->reportingGetDataPost: %s\n" % e)

Parameters

Body parameters
Name Description
body

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


reportingGraphsGet


/reporting/graphs

Usage and SDK Samples

curl -X GET -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/reporting/graphs?limit=&offset=&count=&sort="
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.ReportingApi;

import java.io.File;
import java.util.*;

public class ReportingApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        ReportingApi apiInstance = new ReportingApi();
        Integer limit = 56; // Integer | 
        Integer offset = 56; // Integer | 
        Boolean count = true; // Boolean | 
        String sort = sort_example; // String | 
        try {
            apiInstance.reportingGraphsGet(limit, offset, count, sort);
        } catch (ApiException e) {
            System.err.println("Exception when calling ReportingApi#reportingGraphsGet");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::ReportingApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::ReportingApi->new();
my $limit = 56; # Integer | 
my $offset = 56; # Integer | 
my $count = true; # Boolean | 
my $sort = sort_example; # String | 

eval { 
    $api_instance->reportingGraphsGet(limit => $limit, offset => $offset, count => $count, sort => $sort);
};
if ($@) {
    warn "Exception when calling ReportingApi->reportingGraphsGet: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.ReportingApi()
limit = 56 # Integer |  (optional)
offset = 56 # Integer |  (optional)
count = true # Boolean |  (optional)
sort = sort_example # String |  (optional)

try: 
    api_instance.reporting_graphs_get(limit=limit, offset=offset, count=count, sort=sort)
except ApiException as e:
    print("Exception when calling ReportingApi->reportingGraphsGet: %s\n" % e)

Parameters

Query parameters
Name Description
limit
Integer
offset
Integer
count
Boolean
sort
String

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


reportingPut

Configure Reporting Database settings. If `cpu_in_percentage` is `true`, collectd reports CPU usage in percentage instead of "jiffies". `graphite` specifies a destination hostname or IP for collectd data sent by the Graphite plugin.. `graphite_separateinstances` corresponds to collectd SeparateInstances option. `graph_age` specifies the maximum age of stored graphs in months. `graph_points` is the number of points for each hourly, daily, weekly, etc. graph. Changing these requires destroying the current reporting database, so when these fields are changed, an additional `confirm_rrd_destroy: true` flag must be present.


/reporting

Usage and SDK Samples

curl -X PUT -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/reporting"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.ReportingApi;

import java.io.File;
import java.util.*;

public class ReportingApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        ReportingApi apiInstance = new ReportingApi();
        Reporting_update_0 body = ; // Reporting_update_0 | 
        try {
            apiInstance.reportingPut(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling ReportingApi#reportingPut");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::ReportingApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::ReportingApi->new();
my $body = WWW::SwaggerClient::Object::Reporting_update_0->new(); # Reporting_update_0 | 

eval { 
    $api_instance->reportingPut(body => $body);
};
if ($@) {
    warn "Exception when calling ReportingApi->reportingPut: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.ReportingApi()
body =  # Reporting_update_0 |  (optional)

try: 
    api_instance.reporting_put(body=body)
except ApiException as e:
    print("Exception when calling ReportingApi->reportingPut: %s\n" % e)

Parameters

Body parameters
Name Description
body

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


Route

routeIpv4gwReachablePost

Get the IPv4 gateway and verify if it is reachable by any interface. Returns: bool: True if the gateway is reachable or otherwise False.


/route/ipv4gw_reachable

Usage and SDK Samples

curl -X POST -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/route/ipv4gw_reachable"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.RouteApi;

import java.io.File;
import java.util.*;

public class RouteApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        RouteApi apiInstance = new RouteApi();
        String body = ; // String | 
        try {
            apiInstance.routeIpv4gwReachablePost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling RouteApi#routeIpv4gwReachablePost");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::RouteApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::RouteApi->new();
my $body = WWW::SwaggerClient::Object::String->new(); # String | 

eval { 
    $api_instance->routeIpv4gwReachablePost(body => $body);
};
if ($@) {
    warn "Exception when calling RouteApi->routeIpv4gwReachablePost: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.RouteApi()
body =  # String |  (optional)

try: 
    api_instance.route_ipv4gw_reachable_post(body=body)
except ApiException as e:
    print("Exception when calling RouteApi->routeIpv4gwReachablePost: %s\n" % e)

Parameters

Body parameters
Name Description
body

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


routeSystemRoutesGet

Get current/applied network routes.


/route/system_routes

Usage and SDK Samples

curl -X GET -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/route/system_routes?limit=&offset=&count=&sort="
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.RouteApi;

import java.io.File;
import java.util.*;

public class RouteApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        RouteApi apiInstance = new RouteApi();
        Integer limit = 56; // Integer | 
        Integer offset = 56; // Integer | 
        Boolean count = true; // Boolean | 
        String sort = sort_example; // String | 
        try {
            apiInstance.routeSystemRoutesGet(limit, offset, count, sort);
        } catch (ApiException e) {
            System.err.println("Exception when calling RouteApi#routeSystemRoutesGet");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::RouteApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::RouteApi->new();
my $limit = 56; # Integer | 
my $offset = 56; # Integer | 
my $count = true; # Boolean | 
my $sort = sort_example; # String | 

eval { 
    $api_instance->routeSystemRoutesGet(limit => $limit, offset => $offset, count => $count, sort => $sort);
};
if ($@) {
    warn "Exception when calling RouteApi->routeSystemRoutesGet: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.RouteApi()
limit = 56 # Integer |  (optional)
offset = 56 # Integer |  (optional)
count = true # Boolean |  (optional)
sort = sort_example # String |  (optional)

try: 
    api_instance.route_system_routes_get(limit=limit, offset=offset, count=count, sort=sort)
except ApiException as e:
    print("Exception when calling RouteApi->routeSystemRoutesGet: %s\n" % e)

Parameters

Query parameters
Name Description
limit
Integer
offset
Integer
count
Boolean
sort
String

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


Rsyncd

rsyncdGet


/rsyncd

Usage and SDK Samples

curl -X GET -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/rsyncd"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.RsyncdApi;

import java.io.File;
import java.util.*;

public class RsyncdApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        RsyncdApi apiInstance = new RsyncdApi();
        try {
            apiInstance.rsyncdGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling RsyncdApi#rsyncdGet");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::RsyncdApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::RsyncdApi->new();

eval { 
    $api_instance->rsyncdGet();
};
if ($@) {
    warn "Exception when calling RsyncdApi->rsyncdGet: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.RsyncdApi()

try: 
    api_instance.rsyncd_get()
except ApiException as e:
    print("Exception when calling RsyncdApi->rsyncdGet: %s\n" % e)

Parameters

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


rsyncdPut

Update Rsyncd Service Configuration. `auxiliary` attribute can be used to pass on any additional parameters from rsyncd.conf(5).


/rsyncd

Usage and SDK Samples

curl -X PUT -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/rsyncd"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.RsyncdApi;

import java.io.File;
import java.util.*;

public class RsyncdApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        RsyncdApi apiInstance = new RsyncdApi();
        Rsyncd_update_0 body = ; // Rsyncd_update_0 | 
        try {
            apiInstance.rsyncdPut(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling RsyncdApi#rsyncdPut");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::RsyncdApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::RsyncdApi->new();
my $body = WWW::SwaggerClient::Object::Rsyncd_update_0->new(); # Rsyncd_update_0 | 

eval { 
    $api_instance->rsyncdPut(body => $body);
};
if ($@) {
    warn "Exception when calling RsyncdApi->rsyncdPut: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.RsyncdApi()
body =  # Rsyncd_update_0 |  (optional)

try: 
    api_instance.rsyncd_put(body=body)
except ApiException as e:
    print("Exception when calling RsyncdApi->rsyncdPut: %s\n" % e)

Parameters

Body parameters
Name Description
body

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


Rsyncmod

rsyncmodGet


/rsyncmod

Usage and SDK Samples

curl -X GET -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/rsyncmod?limit=&offset=&count=&sort="
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.RsyncmodApi;

import java.io.File;
import java.util.*;

public class RsyncmodApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        RsyncmodApi apiInstance = new RsyncmodApi();
        Integer limit = 56; // Integer | 
        Integer offset = 56; // Integer | 
        Boolean count = true; // Boolean | 
        String sort = sort_example; // String | 
        try {
            apiInstance.rsyncmodGet(limit, offset, count, sort);
        } catch (ApiException e) {
            System.err.println("Exception when calling RsyncmodApi#rsyncmodGet");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::RsyncmodApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::RsyncmodApi->new();
my $limit = 56; # Integer | 
my $offset = 56; # Integer | 
my $count = true; # Boolean | 
my $sort = sort_example; # String | 

eval { 
    $api_instance->rsyncmodGet(limit => $limit, offset => $offset, count => $count, sort => $sort);
};
if ($@) {
    warn "Exception when calling RsyncmodApi->rsyncmodGet: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.RsyncmodApi()
limit = 56 # Integer |  (optional)
offset = 56 # Integer |  (optional)
count = true # Boolean |  (optional)
sort = sort_example # String |  (optional)

try: 
    api_instance.rsyncmod_get(limit=limit, offset=offset, count=count, sort=sort)
except ApiException as e:
    print("Exception when calling RsyncmodApi->rsyncmodGet: %s\n" % e)

Parameters

Query parameters
Name Description
limit
Integer
offset
Integer
count
Boolean
sort
String

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


rsyncmodIdIdDelete

Delete Rsyncmod module of `id`.


/rsyncmod/id/{id}

Usage and SDK Samples

curl -X DELETE -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/rsyncmod/id/{id}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.RsyncmodApi;

import java.io.File;
import java.util.*;

public class RsyncmodApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        RsyncmodApi apiInstance = new RsyncmodApi();
        Integer id = 56; // Integer | 
        try {
            apiInstance.rsyncmodIdIdDelete(id);
        } catch (ApiException e) {
            System.err.println("Exception when calling RsyncmodApi#rsyncmodIdIdDelete");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::RsyncmodApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::RsyncmodApi->new();
my $id = 56; # Integer | 

eval { 
    $api_instance->rsyncmodIdIdDelete(id => $id);
};
if ($@) {
    warn "Exception when calling RsyncmodApi->rsyncmodIdIdDelete: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.RsyncmodApi()
id = 56 # Integer | 

try: 
    api_instance.rsyncmod_id_id_delete(id)
except ApiException as e:
    print("Exception when calling RsyncmodApi->rsyncmodIdIdDelete: %s\n" % e)

Parameters

Path parameters
Name Description
id*
Integer
Required

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


rsyncmodIdIdGet


/rsyncmod/id/{id}

Usage and SDK Samples

curl -X GET -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/rsyncmod/id/{id}?limit=&offset=&count=&sort="
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.RsyncmodApi;

import java.io.File;
import java.util.*;

public class RsyncmodApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        RsyncmodApi apiInstance = new RsyncmodApi();
        array[null] id = ; // array[null] | 
        Integer limit = 56; // Integer | 
        Integer offset = 56; // Integer | 
        Boolean count = true; // Boolean | 
        String sort = sort_example; // String | 
        try {
            apiInstance.rsyncmodIdIdGet(id, limit, offset, count, sort);
        } catch (ApiException e) {
            System.err.println("Exception when calling RsyncmodApi#rsyncmodIdIdGet");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::RsyncmodApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::RsyncmodApi->new();
my $id = []; # array[null] | 
my $limit = 56; # Integer | 
my $offset = 56; # Integer | 
my $count = true; # Boolean | 
my $sort = sort_example; # String | 

eval { 
    $api_instance->rsyncmodIdIdGet(id => $id, limit => $limit, offset => $offset, count => $count, sort => $sort);
};
if ($@) {
    warn "Exception when calling RsyncmodApi->rsyncmodIdIdGet: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.RsyncmodApi()
id =  # array[null] | 
limit = 56 # Integer |  (optional)
offset = 56 # Integer |  (optional)
count = true # Boolean |  (optional)
sort = sort_example # String |  (optional)

try: 
    api_instance.rsyncmod_id_id_get(id, limit=limit, offset=offset, count=count, sort=sort)
except ApiException as e:
    print("Exception when calling RsyncmodApi->rsyncmodIdIdGet: %s\n" % e)

Parameters

Path parameters
Name Description
id*
array[null]
Required
Query parameters
Name Description
limit
Integer
offset
Integer
count
Boolean
sort
String

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


rsyncmodIdIdPut

Update Rsyncmod module of `id`.


/rsyncmod/id/{id}

Usage and SDK Samples

curl -X PUT -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/rsyncmod/id/{id}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.RsyncmodApi;

import java.io.File;
import java.util.*;

public class RsyncmodApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        RsyncmodApi apiInstance = new RsyncmodApi();
        Integer id = 56; // Integer | 
        Rsyncmod_update_1 body = ; // Rsyncmod_update_1 | 
        try {
            apiInstance.rsyncmodIdIdPut(id, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling RsyncmodApi#rsyncmodIdIdPut");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::RsyncmodApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::RsyncmodApi->new();
my $id = 56; # Integer | 
my $body = WWW::SwaggerClient::Object::Rsyncmod_update_1->new(); # Rsyncmod_update_1 | 

eval { 
    $api_instance->rsyncmodIdIdPut(id => $id, body => $body);
};
if ($@) {
    warn "Exception when calling RsyncmodApi->rsyncmodIdIdPut: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.RsyncmodApi()
id = 56 # Integer | 
body =  # Rsyncmod_update_1 |  (optional)

try: 
    api_instance.rsyncmod_id_id_put(id, body=body)
except ApiException as e:
    print("Exception when calling RsyncmodApi->rsyncmodIdIdPut: %s\n" % e)

Parameters

Path parameters
Name Description
id*
Integer
Required
Body parameters
Name Description
body

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


rsyncmodPost

Create a Rsyncmod module. `path` represents the path to a dataset. Path length is limited to 1023 characters maximum as per the limit enforced by FreeBSD. It is possible that we reach this max length recursively while transferring data. In that case, the user must ensure the maximum path will not be too long or modify the recursed path to shorter than the limit. `maxconn` is an integer value representing the maximum number of simultaneous connections. Zero represents unlimited. `hostsallow` is a list of patterns to match hostname/ip address of a connecting client. If list is empty, all hosts are allowed. `hostsdeny` is a list of patterns to match hostname/ip address of a connecting client. If the pattern is matched, access is denied to the client. If no client should be denied, this should be left empty. `auxiliary` attribute can be used to pass on any additional parameters from rsyncd.conf(5).


/rsyncmod

Usage and SDK Samples

curl -X POST -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/rsyncmod"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.RsyncmodApi;

import java.io.File;
import java.util.*;

public class RsyncmodApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        RsyncmodApi apiInstance = new RsyncmodApi();
        Rsyncmod_create_0 body = ; // Rsyncmod_create_0 | 
        try {
            apiInstance.rsyncmodPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling RsyncmodApi#rsyncmodPost");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::RsyncmodApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::RsyncmodApi->new();
my $body = WWW::SwaggerClient::Object::Rsyncmod_create_0->new(); # Rsyncmod_create_0 | 

eval { 
    $api_instance->rsyncmodPost(body => $body);
};
if ($@) {
    warn "Exception when calling RsyncmodApi->rsyncmodPost: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.RsyncmodApi()
body =  # Rsyncmod_create_0 |  (optional)

try: 
    api_instance.rsyncmod_post(body=body)
except ApiException as e:
    print("Exception when calling RsyncmodApi->rsyncmodPost: %s\n" % e)

Parameters

Body parameters
Name Description
body

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


Rsynctask

rsynctaskGet


/rsynctask

Usage and SDK Samples

curl -X GET -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/rsynctask?limit=&offset=&count=&sort="
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.RsynctaskApi;

import java.io.File;
import java.util.*;

public class RsynctaskApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        RsynctaskApi apiInstance = new RsynctaskApi();
        Integer limit = 56; // Integer | 
        Integer offset = 56; // Integer | 
        Boolean count = true; // Boolean | 
        String sort = sort_example; // String | 
        try {
            apiInstance.rsynctaskGet(limit, offset, count, sort);
        } catch (ApiException e) {
            System.err.println("Exception when calling RsynctaskApi#rsynctaskGet");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::RsynctaskApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::RsynctaskApi->new();
my $limit = 56; # Integer | 
my $offset = 56; # Integer | 
my $count = true; # Boolean | 
my $sort = sort_example; # String | 

eval { 
    $api_instance->rsynctaskGet(limit => $limit, offset => $offset, count => $count, sort => $sort);
};
if ($@) {
    warn "Exception when calling RsynctaskApi->rsynctaskGet: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.RsynctaskApi()
limit = 56 # Integer |  (optional)
offset = 56 # Integer |  (optional)
count = true # Boolean |  (optional)
sort = sort_example # String |  (optional)

try: 
    api_instance.rsynctask_get(limit=limit, offset=offset, count=count, sort=sort)
except ApiException as e:
    print("Exception when calling RsynctaskApi->rsynctaskGet: %s\n" % e)

Parameters

Query parameters
Name Description
limit
Integer
offset
Integer
count
Boolean
sort
String

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


rsynctaskIdIdDelete

Delete Rsync Task of `id`.


/rsynctask/id/{id}

Usage and SDK Samples

curl -X DELETE -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/rsynctask/id/{id}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.RsynctaskApi;

import java.io.File;
import java.util.*;

public class RsynctaskApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        RsynctaskApi apiInstance = new RsynctaskApi();
        Integer id = 56; // Integer | 
        try {
            apiInstance.rsynctaskIdIdDelete(id);
        } catch (ApiException e) {
            System.err.println("Exception when calling RsynctaskApi#rsynctaskIdIdDelete");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::RsynctaskApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::RsynctaskApi->new();
my $id = 56; # Integer | 

eval { 
    $api_instance->rsynctaskIdIdDelete(id => $id);
};
if ($@) {
    warn "Exception when calling RsynctaskApi->rsynctaskIdIdDelete: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.RsynctaskApi()
id = 56 # Integer | 

try: 
    api_instance.rsynctask_id_id_delete(id)
except ApiException as e:
    print("Exception when calling RsynctaskApi->rsynctaskIdIdDelete: %s\n" % e)

Parameters

Path parameters
Name Description
id*
Integer
Required

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


rsynctaskIdIdGet


/rsynctask/id/{id}

Usage and SDK Samples

curl -X GET -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/rsynctask/id/{id}?limit=&offset=&count=&sort="
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.RsynctaskApi;

import java.io.File;
import java.util.*;

public class RsynctaskApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        RsynctaskApi apiInstance = new RsynctaskApi();
        array[null] id = ; // array[null] | 
        Integer limit = 56; // Integer | 
        Integer offset = 56; // Integer | 
        Boolean count = true; // Boolean | 
        String sort = sort_example; // String | 
        try {
            apiInstance.rsynctaskIdIdGet(id, limit, offset, count, sort);
        } catch (ApiException e) {
            System.err.println("Exception when calling RsynctaskApi#rsynctaskIdIdGet");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::RsynctaskApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::RsynctaskApi->new();
my $id = []; # array[null] | 
my $limit = 56; # Integer | 
my $offset = 56; # Integer | 
my $count = true; # Boolean | 
my $sort = sort_example; # String | 

eval { 
    $api_instance->rsynctaskIdIdGet(id => $id, limit => $limit, offset => $offset, count => $count, sort => $sort);
};
if ($@) {
    warn "Exception when calling RsynctaskApi->rsynctaskIdIdGet: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.RsynctaskApi()
id =  # array[null] | 
limit = 56 # Integer |  (optional)
offset = 56 # Integer |  (optional)
count = true # Boolean |  (optional)
sort = sort_example # String |  (optional)

try: 
    api_instance.rsynctask_id_id_get(id, limit=limit, offset=offset, count=count, sort=sort)
except ApiException as e:
    print("Exception when calling RsynctaskApi->rsynctaskIdIdGet: %s\n" % e)

Parameters

Path parameters
Name Description
id*
array[null]
Required
Query parameters
Name Description
limit
Integer
offset
Integer
count
Boolean
sort
String

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


rsynctaskIdIdPut

Update Rsync Task of `id`.


/rsynctask/id/{id}

Usage and SDK Samples

curl -X PUT -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/rsynctask/id/{id}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.RsynctaskApi;

import java.io.File;
import java.util.*;

public class RsynctaskApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        RsynctaskApi apiInstance = new RsynctaskApi();
        Integer id = 56; // Integer | 
        Rsynctask_update_1 body = ; // Rsynctask_update_1 | 
        try {
            apiInstance.rsynctaskIdIdPut(id, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling RsynctaskApi#rsynctaskIdIdPut");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::RsynctaskApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::RsynctaskApi->new();
my $id = 56; # Integer | 
my $body = WWW::SwaggerClient::Object::Rsynctask_update_1->new(); # Rsynctask_update_1 | 

eval { 
    $api_instance->rsynctaskIdIdPut(id => $id, body => $body);
};
if ($@) {
    warn "Exception when calling RsynctaskApi->rsynctaskIdIdPut: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.RsynctaskApi()
id = 56 # Integer | 
body =  # Rsynctask_update_1 |  (optional)

try: 
    api_instance.rsynctask_id_id_put(id, body=body)
except ApiException as e:
    print("Exception when calling RsynctaskApi->rsynctaskIdIdPut: %s\n" % e)

Parameters

Path parameters
Name Description
id*
Integer
Required
Body parameters
Name Description
body

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


rsynctaskIdIdRunPost

Job to run rsync task of `id`. Output is saved to job log excerpt (not syslog).


/rsynctask/id/{id}/run

Usage and SDK Samples

curl -X POST -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/rsynctask/id/{id}/run"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.RsynctaskApi;

import java.io.File;
import java.util.*;

public class RsynctaskApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        RsynctaskApi apiInstance = new RsynctaskApi();
        Integer id = 56; // Integer | 
        Rsynctask_run body = ; // Rsynctask_run | 
        try {
            apiInstance.rsynctaskIdIdRunPost(id, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling RsynctaskApi#rsynctaskIdIdRunPost");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::RsynctaskApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::RsynctaskApi->new();
my $id = 56; # Integer | 
my $body = WWW::SwaggerClient::Object::Rsynctask_run->new(); # Rsynctask_run | 

eval { 
    $api_instance->rsynctaskIdIdRunPost(id => $id, body => $body);
};
if ($@) {
    warn "Exception when calling RsynctaskApi->rsynctaskIdIdRunPost: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.RsynctaskApi()
id = 56 # Integer | 
body =  # Rsynctask_run |  (optional)

try: 
    api_instance.rsynctask_id_id_run_post(id, body=body)
except ApiException as e:
    print("Exception when calling RsynctaskApi->rsynctaskIdIdRunPost: %s\n" % e)

Parameters

Path parameters
Name Description
id*
Integer
Required
Body parameters
Name Description
body

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


rsynctaskPost

Create a Rsync Task. See the comment in Rsyncmod about `path` length limits. `remotehost` is ip address or hostname of the remote system. If username differs on the remote host, "username@remote_host" format should be used. `mode` represents different operating mechanisms for Rsync i.e Rsync Module mode / Rsync SSH mode. `remotemodule` is the name of remote module, this attribute should be specified when `mode` is set to MODULE. `remotepath` specifies the path on the remote system. `validate_rpath` is a boolean which when sets validates the existence of the remote path. `direction` specifies if data should be PULLED or PUSHED from the remote system. `compress` when set reduces the size of the data which is to be transmitted. `archive` when set makes rsync run recursively, preserving symlinks, permissions, modification times, group, and special files. `delete` when set deletes files in the destination directory which do not exist in the source directory. `preserveperm` when set preserves original file permissions.


/rsynctask

Usage and SDK Samples

curl -X POST -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/rsynctask"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.RsynctaskApi;

import java.io.File;
import java.util.*;

public class RsynctaskApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        RsynctaskApi apiInstance = new RsynctaskApi();
        Rsynctask_create_0 body = ; // Rsynctask_create_0 | 
        try {
            apiInstance.rsynctaskPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling RsynctaskApi#rsynctaskPost");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::RsynctaskApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::RsynctaskApi->new();
my $body = WWW::SwaggerClient::Object::Rsynctask_create_0->new(); # Rsynctask_create_0 | 

eval { 
    $api_instance->rsynctaskPost(body => $body);
};
if ($@) {
    warn "Exception when calling RsynctaskApi->rsynctaskPost: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.RsynctaskApi()
body =  # Rsynctask_create_0 |  (optional)

try: 
    api_instance.rsynctask_post(body=body)
except ApiException as e:
    print("Exception when calling RsynctaskApi->rsynctaskPost: %s\n" % e)

Parameters

Body parameters
Name Description
body

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


S3

s3BindipChoicesGet

Return ip choices for S3 service to use.


/s3/bindip_choices

Usage and SDK Samples

curl -X GET -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/s3/bindip_choices"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.S3Api;

import java.io.File;
import java.util.*;

public class S3ApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        S3Api apiInstance = new S3Api();
        try {
            apiInstance.s3BindipChoicesGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling S3Api#s3BindipChoicesGet");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::S3Api;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::S3Api->new();

eval { 
    $api_instance->s3BindipChoicesGet();
};
if ($@) {
    warn "Exception when calling S3Api->s3BindipChoicesGet: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.S3Api()

try: 
    api_instance.s3_bindip_choices_get()
except ApiException as e:
    print("Exception when calling S3Api->s3BindipChoicesGet: %s\n" % e)

Parameters

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


s3Get


/s3

Usage and SDK Samples

curl -X GET -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/s3"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.S3Api;

import java.io.File;
import java.util.*;

public class S3ApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        S3Api apiInstance = new S3Api();
        try {
            apiInstance.s3Get();
        } catch (ApiException e) {
            System.err.println("Exception when calling S3Api#s3Get");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::S3Api;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::S3Api->new();

eval { 
    $api_instance->s3Get();
};
if ($@) {
    warn "Exception when calling S3Api->s3Get: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.S3Api()

try: 
    api_instance.s3_get()
except ApiException as e:
    print("Exception when calling S3Api->s3Get: %s\n" % e)

Parameters

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


s3Put

Update S3 Service Configuration. `access_key` must only contain alphanumeric characters and should be between 5 and 20 characters. `secret_key` must only contain alphanumeric characters and should be between 8 and 40 characters. `browser` when set, enables the web user interface for the S3 Service. `certificate` is a valid certificate id which exists in the system. This is used to enable secure S3 connections.


/s3

Usage and SDK Samples

curl -X PUT -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/s3"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.S3Api;

import java.io.File;
import java.util.*;

public class S3ApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        S3Api apiInstance = new S3Api();
        S3_update_0 body = ; // S3_update_0 | 
        try {
            apiInstance.s3Put(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling S3Api#s3Put");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::S3Api;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::S3Api->new();
my $body = WWW::SwaggerClient::Object::S3_update_0->new(); # S3_update_0 | 

eval { 
    $api_instance->s3Put(body => $body);
};
if ($@) {
    warn "Exception when calling S3Api->s3Put: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.S3Api()
body =  # S3_update_0 |  (optional)

try: 
    api_instance.s3_put(body=body)
except ApiException as e:
    print("Exception when calling S3Api->s3Put: %s\n" % e)

Parameters

Body parameters
Name Description
body

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


Sensor

sensorQueryGet


/sensor/query

Usage and SDK Samples

curl -X GET -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/sensor/query?limit=&offset=&count=&sort="
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.SensorApi;

import java.io.File;
import java.util.*;

public class SensorApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        SensorApi apiInstance = new SensorApi();
        Integer limit = 56; // Integer | 
        Integer offset = 56; // Integer | 
        Boolean count = true; // Boolean | 
        String sort = sort_example; // String | 
        try {
            apiInstance.sensorQueryGet(limit, offset, count, sort);
        } catch (ApiException e) {
            System.err.println("Exception when calling SensorApi#sensorQueryGet");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::SensorApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::SensorApi->new();
my $limit = 56; # Integer | 
my $offset = 56; # Integer | 
my $count = true; # Boolean | 
my $sort = sort_example; # String | 

eval { 
    $api_instance->sensorQueryGet(limit => $limit, offset => $offset, count => $count, sort => $sort);
};
if ($@) {
    warn "Exception when calling SensorApi->sensorQueryGet: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.SensorApi()
limit = 56 # Integer |  (optional)
offset = 56 # Integer |  (optional)
count = true # Boolean |  (optional)
sort = sort_example # String |  (optional)

try: 
    api_instance.sensor_query_get(limit=limit, offset=offset, count=count, sort=sort)
except ApiException as e:
    print("Exception when calling SensorApi->sensorQueryGet: %s\n" % e)

Parameters

Query parameters
Name Description
limit
Integer
offset
Integer
count
Boolean
sort
String

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


Service

serviceGet

Query all system services with `query-filters` and `query-options`.


/service

Usage and SDK Samples

curl -X GET -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/service?limit=&offset=&count=&sort="
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.ServiceApi;

import java.io.File;
import java.util.*;

public class ServiceApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        ServiceApi apiInstance = new ServiceApi();
        Integer limit = 56; // Integer | 
        Integer offset = 56; // Integer | 
        Boolean count = true; // Boolean | 
        String sort = sort_example; // String | 
        try {
            apiInstance.serviceGet(limit, offset, count, sort);
        } catch (ApiException e) {
            System.err.println("Exception when calling ServiceApi#serviceGet");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::ServiceApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::ServiceApi->new();
my $limit = 56; # Integer | 
my $offset = 56; # Integer | 
my $count = true; # Boolean | 
my $sort = sort_example; # String | 

eval { 
    $api_instance->serviceGet(limit => $limit, offset => $offset, count => $count, sort => $sort);
};
if ($@) {
    warn "Exception when calling ServiceApi->serviceGet: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.ServiceApi()
limit = 56 # Integer |  (optional)
offset = 56 # Integer |  (optional)
count = true # Boolean |  (optional)
sort = sort_example # String |  (optional)

try: 
    api_instance.service_get(limit=limit, offset=offset, count=count, sort=sort)
except ApiException as e:
    print("Exception when calling ServiceApi->serviceGet: %s\n" % e)

Parameters

Query parameters
Name Description
limit
Integer
offset
Integer
count
Boolean
sort
String

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


serviceIdIdGet

Query all system services with `query-filters` and `query-options`.


/service/id/{id}

Usage and SDK Samples

curl -X GET -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/service/id/{id}?limit=&offset=&count=&sort="
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.ServiceApi;

import java.io.File;
import java.util.*;

public class ServiceApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        ServiceApi apiInstance = new ServiceApi();
        array[null] id = ; // array[null] | 
        Integer limit = 56; // Integer | 
        Integer offset = 56; // Integer | 
        Boolean count = true; // Boolean | 
        String sort = sort_example; // String | 
        try {
            apiInstance.serviceIdIdGet(id, limit, offset, count, sort);
        } catch (ApiException e) {
            System.err.println("Exception when calling ServiceApi#serviceIdIdGet");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::ServiceApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::ServiceApi->new();
my $id = []; # array[null] | 
my $limit = 56; # Integer | 
my $offset = 56; # Integer | 
my $count = true; # Boolean | 
my $sort = sort_example; # String | 

eval { 
    $api_instance->serviceIdIdGet(id => $id, limit => $limit, offset => $offset, count => $count, sort => $sort);
};
if ($@) {
    warn "Exception when calling ServiceApi->serviceIdIdGet: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.ServiceApi()
id =  # array[null] | 
limit = 56 # Integer |  (optional)
offset = 56 # Integer |  (optional)
count = true # Boolean |  (optional)
sort = sort_example # String |  (optional)

try: 
    api_instance.service_id_id_get(id, limit=limit, offset=offset, count=count, sort=sort)
except ApiException as e:
    print("Exception when calling ServiceApi->serviceIdIdGet: %s\n" % e)

Parameters

Path parameters
Name Description
id*
array[null]
Required
Query parameters
Name Description
limit
Integer
offset
Integer
count
Boolean
sort
String

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


serviceIdIdPut

Update service entry of `id_or_name`. Currently it only accepts `enable` option which means whether the service should start on boot.


/service/id/{id}

Usage and SDK Samples

curl -X PUT -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/service/id/{id}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.ServiceApi;

import java.io.File;
import java.util.*;

public class ServiceApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        ServiceApi apiInstance = new ServiceApi();
        String id = id_example; // String | 
        Service_update_1 body = ; // Service_update_1 | 
        try {
            apiInstance.serviceIdIdPut(id, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling ServiceApi#serviceIdIdPut");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::ServiceApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::ServiceApi->new();
my $id = id_example; # String | 
my $body = WWW::SwaggerClient::Object::Service_update_1->new(); # Service_update_1 | 

eval { 
    $api_instance->serviceIdIdPut(id => $id, body => $body);
};
if ($@) {
    warn "Exception when calling ServiceApi->serviceIdIdPut: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.ServiceApi()
id = id_example # String | 
body =  # Service_update_1 |  (optional)

try: 
    api_instance.service_id_id_put(id, body=body)
except ApiException as e:
    print("Exception when calling ServiceApi->serviceIdIdPut: %s\n" % e)

Parameters

Path parameters
Name Description
id*
String
Required
Body parameters
Name Description
body

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


serviceReloadPost

Reload the service specified by `service`.


/service/reload

Usage and SDK Samples

curl -X POST -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/service/reload"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.ServiceApi;

import java.io.File;
import java.util.*;

public class ServiceApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        ServiceApi apiInstance = new ServiceApi();
        Service_reload body = ; // Service_reload | 
        try {
            apiInstance.serviceReloadPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling ServiceApi#serviceReloadPost");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::ServiceApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::ServiceApi->new();
my $body = WWW::SwaggerClient::Object::Service_reload->new(); # Service_reload | 

eval { 
    $api_instance->serviceReloadPost(body => $body);
};
if ($@) {
    warn "Exception when calling ServiceApi->serviceReloadPost: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.ServiceApi()
body =  # Service_reload |  (optional)

try: 
    api_instance.service_reload_post(body=body)
except ApiException as e:
    print("Exception when calling ServiceApi->serviceReloadPost: %s\n" % e)

Parameters

Body parameters
Name Description
body

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


serviceRestartPost

Restart the service specified by `service`.


/service/restart

Usage and SDK Samples

curl -X POST -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/service/restart"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.ServiceApi;

import java.io.File;
import java.util.*;

public class ServiceApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        ServiceApi apiInstance = new ServiceApi();
        Service_restart body = ; // Service_restart | 
        try {
            apiInstance.serviceRestartPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling ServiceApi#serviceRestartPost");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::ServiceApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::ServiceApi->new();
my $body = WWW::SwaggerClient::Object::Service_restart->new(); # Service_restart | 

eval { 
    $api_instance->serviceRestartPost(body => $body);
};
if ($@) {
    warn "Exception when calling ServiceApi->serviceRestartPost: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.ServiceApi()
body =  # Service_restart |  (optional)

try: 
    api_instance.service_restart_post(body=body)
except ApiException as e:
    print("Exception when calling ServiceApi->serviceRestartPost: %s\n" % e)

Parameters

Body parameters
Name Description
body

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


serviceStartPost

Start the service specified by `service`.


/service/start

Usage and SDK Samples

curl -X POST -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/service/start"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.ServiceApi;

import java.io.File;
import java.util.*;

public class ServiceApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        ServiceApi apiInstance = new ServiceApi();
        Service_start body = ; // Service_start | 
        try {
            apiInstance.serviceStartPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling ServiceApi#serviceStartPost");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::ServiceApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::ServiceApi->new();
my $body = WWW::SwaggerClient::Object::Service_start->new(); # Service_start | 

eval { 
    $api_instance->serviceStartPost(body => $body);
};
if ($@) {
    warn "Exception when calling ServiceApi->serviceStartPost: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.ServiceApi()
body =  # Service_start |  (optional)

try: 
    api_instance.service_start_post(body=body)
except ApiException as e:
    print("Exception when calling ServiceApi->serviceStartPost: %s\n" % e)

Parameters

Body parameters
Name Description
body

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


serviceStartedGet

Test if service specified by `service` has been started.


/service/started

Usage and SDK Samples

curl -X GET -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/service/started"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.ServiceApi;

import java.io.File;
import java.util.*;

public class ServiceApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        ServiceApi apiInstance = new ServiceApi();
        try {
            apiInstance.serviceStartedGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling ServiceApi#serviceStartedGet");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::ServiceApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::ServiceApi->new();

eval { 
    $api_instance->serviceStartedGet();
};
if ($@) {
    warn "Exception when calling ServiceApi->serviceStartedGet: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.ServiceApi()

try: 
    api_instance.service_started_get()
except ApiException as e:
    print("Exception when calling ServiceApi->serviceStartedGet: %s\n" % e)

Parameters

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


serviceStopPost

Stop the service specified by `service`.


/service/stop

Usage and SDK Samples

curl -X POST -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/service/stop"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.ServiceApi;

import java.io.File;
import java.util.*;

public class ServiceApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        ServiceApi apiInstance = new ServiceApi();
        Service_stop body = ; // Service_stop | 
        try {
            apiInstance.serviceStopPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling ServiceApi#serviceStopPost");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::ServiceApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::ServiceApi->new();
my $body = WWW::SwaggerClient::Object::Service_stop->new(); # Service_stop | 

eval { 
    $api_instance->serviceStopPost(body => $body);
};
if ($@) {
    warn "Exception when calling ServiceApi->serviceStopPost: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.ServiceApi()
body =  # Service_stop |  (optional)

try: 
    api_instance.service_stop_post(body=body)
except ApiException as e:
    print("Exception when calling ServiceApi->serviceStopPost: %s\n" % e)

Parameters

Body parameters
Name Description
body

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


serviceTerminateProcessPost

Terminate process by `pid`. First send `TERM` signal, then, if was not terminated in `timeout` seconds, send `KILL` signal. Returns `true` is process has been successfully terminated with `TERM` and `false` if we had to use `KILL`.


/service/terminate_process

Usage and SDK Samples

curl -X POST -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/service/terminate_process"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.ServiceApi;

import java.io.File;
import java.util.*;

public class ServiceApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        ServiceApi apiInstance = new ServiceApi();
        Service_terminate_process body = ; // Service_terminate_process | 
        try {
            apiInstance.serviceTerminateProcessPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling ServiceApi#serviceTerminateProcessPost");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::ServiceApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::ServiceApi->new();
my $body = WWW::SwaggerClient::Object::Service_terminate_process->new(); # Service_terminate_process | 

eval { 
    $api_instance->serviceTerminateProcessPost(body => $body);
};
if ($@) {
    warn "Exception when calling ServiceApi->serviceTerminateProcessPost: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.ServiceApi()
body =  # Service_terminate_process |  (optional)

try: 
    api_instance.service_terminate_process_post(body=body)
except ApiException as e:
    print("Exception when calling ServiceApi->serviceTerminateProcessPost: %s\n" % e)

Parameters

Body parameters
Name Description
body

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


Sharing

sharingGet


/sharing

Usage and SDK Samples

curl -X GET -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/sharing?limit=&offset=&count=&sort="
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.SharingApi;

import java.io.File;
import java.util.*;

public class SharingApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        SharingApi apiInstance = new SharingApi();
        Integer limit = 56; // Integer | 
        Integer offset = 56; // Integer | 
        Boolean count = true; // Boolean | 
        String sort = sort_example; // String | 
        try {
            apiInstance.sharingGet(limit, offset, count, sort);
        } catch (ApiException e) {
            System.err.println("Exception when calling SharingApi#sharingGet");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::SharingApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::SharingApi->new();
my $limit = 56; # Integer | 
my $offset = 56; # Integer | 
my $count = true; # Boolean | 
my $sort = sort_example; # String | 

eval { 
    $api_instance->sharingGet(limit => $limit, offset => $offset, count => $count, sort => $sort);
};
if ($@) {
    warn "Exception when calling SharingApi->sharingGet: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.SharingApi()
limit = 56 # Integer |  (optional)
offset = 56 # Integer |  (optional)
count = true # Boolean |  (optional)
sort = sort_example # String |  (optional)

try: 
    api_instance.sharing_get(limit=limit, offset=offset, count=count, sort=sort)
except ApiException as e:
    print("Exception when calling SharingApi->sharingGet: %s\n" % e)

Parameters

Query parameters
Name Description
limit
Integer
offset
Integer
count
Boolean
sort
String

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


sharingIdIdGet


/sharing/id/{id}

Usage and SDK Samples

curl -X GET -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/sharing/id/{id}?limit=&offset=&count=&sort="
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.SharingApi;

import java.io.File;
import java.util.*;

public class SharingApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        SharingApi apiInstance = new SharingApi();
        array[null] id = ; // array[null] | 
        Integer limit = 56; // Integer | 
        Integer offset = 56; // Integer | 
        Boolean count = true; // Boolean | 
        String sort = sort_example; // String | 
        try {
            apiInstance.sharingIdIdGet(id, limit, offset, count, sort);
        } catch (ApiException e) {
            System.err.println("Exception when calling SharingApi#sharingIdIdGet");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::SharingApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::SharingApi->new();
my $id = []; # array[null] | 
my $limit = 56; # Integer | 
my $offset = 56; # Integer | 
my $count = true; # Boolean | 
my $sort = sort_example; # String | 

eval { 
    $api_instance->sharingIdIdGet(id => $id, limit => $limit, offset => $offset, count => $count, sort => $sort);
};
if ($@) {
    warn "Exception when calling SharingApi->sharingIdIdGet: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.SharingApi()
id =  # array[null] | 
limit = 56 # Integer |  (optional)
offset = 56 # Integer |  (optional)
count = true # Boolean |  (optional)
sort = sort_example # String |  (optional)

try: 
    api_instance.sharing_id_id_get(id, limit=limit, offset=offset, count=count, sort=sort)
except ApiException as e:
    print("Exception when calling SharingApi->sharingIdIdGet: %s\n" % e)

Parameters

Path parameters
Name Description
id*
array[null]
Required
Query parameters
Name Description
limit
Integer
offset
Integer
count
Boolean
sort
String

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


SharingAfp

sharingAfpGet


/sharing/afp

Usage and SDK Samples

curl -X GET -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/sharing/afp?limit=&offset=&count=&sort="
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.SharingAfpApi;

import java.io.File;
import java.util.*;

public class SharingAfpApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        SharingAfpApi apiInstance = new SharingAfpApi();
        Integer limit = 56; // Integer | 
        Integer offset = 56; // Integer | 
        Boolean count = true; // Boolean | 
        String sort = sort_example; // String | 
        try {
            apiInstance.sharingAfpGet(limit, offset, count, sort);
        } catch (ApiException e) {
            System.err.println("Exception when calling SharingAfpApi#sharingAfpGet");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::SharingAfpApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::SharingAfpApi->new();
my $limit = 56; # Integer | 
my $offset = 56; # Integer | 
my $count = true; # Boolean | 
my $sort = sort_example; # String | 

eval { 
    $api_instance->sharingAfpGet(limit => $limit, offset => $offset, count => $count, sort => $sort);
};
if ($@) {
    warn "Exception when calling SharingAfpApi->sharingAfpGet: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.SharingAfpApi()
limit = 56 # Integer |  (optional)
offset = 56 # Integer |  (optional)
count = true # Boolean |  (optional)
sort = sort_example # String |  (optional)

try: 
    api_instance.sharing_afp_get(limit=limit, offset=offset, count=count, sort=sort)
except ApiException as e:
    print("Exception when calling SharingAfpApi->sharingAfpGet: %s\n" % e)

Parameters

Query parameters
Name Description
limit
Integer
offset
Integer
count
Boolean
sort
String

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


sharingAfpIdIdDelete

Delete AFP share `id`.


/sharing/afp/id/{id}

Usage and SDK Samples

curl -X DELETE -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/sharing/afp/id/{id}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.SharingAfpApi;

import java.io.File;
import java.util.*;

public class SharingAfpApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        SharingAfpApi apiInstance = new SharingAfpApi();
        Integer id = 56; // Integer | 
        try {
            apiInstance.sharingAfpIdIdDelete(id);
        } catch (ApiException e) {
            System.err.println("Exception when calling SharingAfpApi#sharingAfpIdIdDelete");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::SharingAfpApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::SharingAfpApi->new();
my $id = 56; # Integer | 

eval { 
    $api_instance->sharingAfpIdIdDelete(id => $id);
};
if ($@) {
    warn "Exception when calling SharingAfpApi->sharingAfpIdIdDelete: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.SharingAfpApi()
id = 56 # Integer | 

try: 
    api_instance.sharing_afp_id_id_delete(id)
except ApiException as e:
    print("Exception when calling SharingAfpApi->sharingAfpIdIdDelete: %s\n" % e)

Parameters

Path parameters
Name Description
id*
Integer
Required

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


sharingAfpIdIdGet


/sharing/afp/id/{id}

Usage and SDK Samples

curl -X GET -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/sharing/afp/id/{id}?limit=&offset=&count=&sort="
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.SharingAfpApi;

import java.io.File;
import java.util.*;

public class SharingAfpApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        SharingAfpApi apiInstance = new SharingAfpApi();
        array[null] id = ; // array[null] | 
        Integer limit = 56; // Integer | 
        Integer offset = 56; // Integer | 
        Boolean count = true; // Boolean | 
        String sort = sort_example; // String | 
        try {
            apiInstance.sharingAfpIdIdGet(id, limit, offset, count, sort);
        } catch (ApiException e) {
            System.err.println("Exception when calling SharingAfpApi#sharingAfpIdIdGet");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::SharingAfpApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::SharingAfpApi->new();
my $id = []; # array[null] | 
my $limit = 56; # Integer | 
my $offset = 56; # Integer | 
my $count = true; # Boolean | 
my $sort = sort_example; # String | 

eval { 
    $api_instance->sharingAfpIdIdGet(id => $id, limit => $limit, offset => $offset, count => $count, sort => $sort);
};
if ($@) {
    warn "Exception when calling SharingAfpApi->sharingAfpIdIdGet: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.SharingAfpApi()
id =  # array[null] | 
limit = 56 # Integer |  (optional)
offset = 56 # Integer |  (optional)
count = true # Boolean |  (optional)
sort = sort_example # String |  (optional)

try: 
    api_instance.sharing_afp_id_id_get(id, limit=limit, offset=offset, count=count, sort=sort)
except ApiException as e:
    print("Exception when calling SharingAfpApi->sharingAfpIdIdGet: %s\n" % e)

Parameters

Path parameters
Name Description
id*
array[null]
Required
Query parameters
Name Description
limit
Integer
offset
Integer
count
Boolean
sort
String

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


sharingAfpIdIdPut

Update AFP share `id`.


/sharing/afp/id/{id}

Usage and SDK Samples

curl -X PUT -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/sharing/afp/id/{id}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.SharingAfpApi;

import java.io.File;
import java.util.*;

public class SharingAfpApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        SharingAfpApi apiInstance = new SharingAfpApi();
        Integer id = 56; // Integer | 
        Sharing_afp_update_1 body = ; // Sharing_afp_update_1 | 
        try {
            apiInstance.sharingAfpIdIdPut(id, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling SharingAfpApi#sharingAfpIdIdPut");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::SharingAfpApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::SharingAfpApi->new();
my $id = 56; # Integer | 
my $body = WWW::SwaggerClient::Object::Sharing_afp_update_1->new(); # Sharing_afp_update_1 | 

eval { 
    $api_instance->sharingAfpIdIdPut(id => $id, body => $body);
};
if ($@) {
    warn "Exception when calling SharingAfpApi->sharingAfpIdIdPut: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.SharingAfpApi()
id = 56 # Integer | 
body =  # Sharing_afp_update_1 |  (optional)

try: 
    api_instance.sharing_afp_id_id_put(id, body=body)
except ApiException as e:
    print("Exception when calling SharingAfpApi->sharingAfpIdIdPut: %s\n" % e)

Parameters

Path parameters
Name Description
id*
Integer
Required
Body parameters
Name Description
body

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


sharingAfpPost

Create AFP share. `allow`, `deny`, `ro`, and `rw` are lists of users and groups. Groups are designated by an @ prefix. `hostsallow` and `hostsdeny` are lists of hosts and/or networks.


/sharing/afp

Usage and SDK Samples

curl -X POST -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/sharing/afp"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.SharingAfpApi;

import java.io.File;
import java.util.*;

public class SharingAfpApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        SharingAfpApi apiInstance = new SharingAfpApi();
        Sharing_afp_create_0 body = ; // Sharing_afp_create_0 | 
        try {
            apiInstance.sharingAfpPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling SharingAfpApi#sharingAfpPost");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::SharingAfpApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::SharingAfpApi->new();
my $body = WWW::SwaggerClient::Object::Sharing_afp_create_0->new(); # Sharing_afp_create_0 | 

eval { 
    $api_instance->sharingAfpPost(body => $body);
};
if ($@) {
    warn "Exception when calling SharingAfpApi->sharingAfpPost: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.SharingAfpApi()
body =  # Sharing_afp_create_0 |  (optional)

try: 
    api_instance.sharing_afp_post(body=body)
except ApiException as e:
    print("Exception when calling SharingAfpApi->sharingAfpPost: %s\n" % e)

Parameters

Body parameters
Name Description
body

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


SharingNfs

sharingNfsGet


/sharing/nfs

Usage and SDK Samples

curl -X GET -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/sharing/nfs?limit=&offset=&count=&sort="
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.SharingNfsApi;

import java.io.File;
import java.util.*;

public class SharingNfsApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        SharingNfsApi apiInstance = new SharingNfsApi();
        Integer limit = 56; // Integer | 
        Integer offset = 56; // Integer | 
        Boolean count = true; // Boolean | 
        String sort = sort_example; // String | 
        try {
            apiInstance.sharingNfsGet(limit, offset, count, sort);
        } catch (ApiException e) {
            System.err.println("Exception when calling SharingNfsApi#sharingNfsGet");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::SharingNfsApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::SharingNfsApi->new();
my $limit = 56; # Integer | 
my $offset = 56; # Integer | 
my $count = true; # Boolean | 
my $sort = sort_example; # String | 

eval { 
    $api_instance->sharingNfsGet(limit => $limit, offset => $offset, count => $count, sort => $sort);
};
if ($@) {
    warn "Exception when calling SharingNfsApi->sharingNfsGet: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.SharingNfsApi()
limit = 56 # Integer |  (optional)
offset = 56 # Integer |  (optional)
count = true # Boolean |  (optional)
sort = sort_example # String |  (optional)

try: 
    api_instance.sharing_nfs_get(limit=limit, offset=offset, count=count, sort=sort)
except ApiException as e:
    print("Exception when calling SharingNfsApi->sharingNfsGet: %s\n" % e)

Parameters

Query parameters
Name Description
limit
Integer
offset
Integer
count
Boolean
sort
String

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


sharingNfsHumanIdentifierGet


/sharing/nfs/human_identifier

Usage and SDK Samples

curl -X GET -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/sharing/nfs/human_identifier"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.SharingNfsApi;

import java.io.File;
import java.util.*;

public class SharingNfsApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        SharingNfsApi apiInstance = new SharingNfsApi();
        try {
            apiInstance.sharingNfsHumanIdentifierGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling SharingNfsApi#sharingNfsHumanIdentifierGet");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::SharingNfsApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::SharingNfsApi->new();

eval { 
    $api_instance->sharingNfsHumanIdentifierGet();
};
if ($@) {
    warn "Exception when calling SharingNfsApi->sharingNfsHumanIdentifierGet: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.SharingNfsApi()

try: 
    api_instance.sharing_nfs_human_identifier_get()
except ApiException as e:
    print("Exception when calling SharingNfsApi->sharingNfsHumanIdentifierGet: %s\n" % e)

Parameters

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


sharingNfsIdIdDelete

Delete NFS Share of `id`.


/sharing/nfs/id/{id}

Usage and SDK Samples

curl -X DELETE -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/sharing/nfs/id/{id}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.SharingNfsApi;

import java.io.File;
import java.util.*;

public class SharingNfsApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        SharingNfsApi apiInstance = new SharingNfsApi();
        Integer id = 56; // Integer | 
        try {
            apiInstance.sharingNfsIdIdDelete(id);
        } catch (ApiException e) {
            System.err.println("Exception when calling SharingNfsApi#sharingNfsIdIdDelete");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::SharingNfsApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::SharingNfsApi->new();
my $id = 56; # Integer | 

eval { 
    $api_instance->sharingNfsIdIdDelete(id => $id);
};
if ($@) {
    warn "Exception when calling SharingNfsApi->sharingNfsIdIdDelete: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.SharingNfsApi()
id = 56 # Integer | 

try: 
    api_instance.sharing_nfs_id_id_delete(id)
except ApiException as e:
    print("Exception when calling SharingNfsApi->sharingNfsIdIdDelete: %s\n" % e)

Parameters

Path parameters
Name Description
id*
Integer
Required

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


sharingNfsIdIdGet


/sharing/nfs/id/{id}

Usage and SDK Samples

curl -X GET -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/sharing/nfs/id/{id}?limit=&offset=&count=&sort="
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.SharingNfsApi;

import java.io.File;
import java.util.*;

public class SharingNfsApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        SharingNfsApi apiInstance = new SharingNfsApi();
        array[null] id = ; // array[null] | 
        Integer limit = 56; // Integer | 
        Integer offset = 56; // Integer | 
        Boolean count = true; // Boolean | 
        String sort = sort_example; // String | 
        try {
            apiInstance.sharingNfsIdIdGet(id, limit, offset, count, sort);
        } catch (ApiException e) {
            System.err.println("Exception when calling SharingNfsApi#sharingNfsIdIdGet");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::SharingNfsApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::SharingNfsApi->new();
my $id = []; # array[null] | 
my $limit = 56; # Integer | 
my $offset = 56; # Integer | 
my $count = true; # Boolean | 
my $sort = sort_example; # String | 

eval { 
    $api_instance->sharingNfsIdIdGet(id => $id, limit => $limit, offset => $offset, count => $count, sort => $sort);
};
if ($@) {
    warn "Exception when calling SharingNfsApi->sharingNfsIdIdGet: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.SharingNfsApi()
id =  # array[null] | 
limit = 56 # Integer |  (optional)
offset = 56 # Integer |  (optional)
count = true # Boolean |  (optional)
sort = sort_example # String |  (optional)

try: 
    api_instance.sharing_nfs_id_id_get(id, limit=limit, offset=offset, count=count, sort=sort)
except ApiException as e:
    print("Exception when calling SharingNfsApi->sharingNfsIdIdGet: %s\n" % e)

Parameters

Path parameters
Name Description
id*
array[null]
Required
Query parameters
Name Description
limit
Integer
offset
Integer
count
Boolean
sort
String

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


sharingNfsIdIdPut

Update NFS Share of `id`.


/sharing/nfs/id/{id}

Usage and SDK Samples

curl -X PUT -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/sharing/nfs/id/{id}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.SharingNfsApi;

import java.io.File;
import java.util.*;

public class SharingNfsApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        SharingNfsApi apiInstance = new SharingNfsApi();
        Integer id = 56; // Integer | 
        Sharing_nfs_update_1 body = ; // Sharing_nfs_update_1 | 
        try {
            apiInstance.sharingNfsIdIdPut(id, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling SharingNfsApi#sharingNfsIdIdPut");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::SharingNfsApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::SharingNfsApi->new();
my $id = 56; # Integer | 
my $body = WWW::SwaggerClient::Object::Sharing_nfs_update_1->new(); # Sharing_nfs_update_1 | 

eval { 
    $api_instance->sharingNfsIdIdPut(id => $id, body => $body);
};
if ($@) {
    warn "Exception when calling SharingNfsApi->sharingNfsIdIdPut: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.SharingNfsApi()
id = 56 # Integer | 
body =  # Sharing_nfs_update_1 |  (optional)

try: 
    api_instance.sharing_nfs_id_id_put(id, body=body)
except ApiException as e:
    print("Exception when calling SharingNfsApi->sharingNfsIdIdPut: %s\n" % e)

Parameters

Path parameters
Name Description
id*
Integer
Required
Body parameters
Name Description
body

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


sharingNfsPost

Create a NFS Share. `paths` is a list of valid paths which are configured to be shared on this share. `networks` is a list of authorized networks that are allowed to access the share having format "network/mask" CIDR notation. If empty, all networks are allowed. `hosts` is a list of IP's/hostnames which are allowed to access the share. If empty, all IP's/hostnames are allowed. `alldirs` is a boolean value which when set indicates that the client can mount any subdirectories of the selected pool or dataset.


/sharing/nfs

Usage and SDK Samples

curl -X POST -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/sharing/nfs"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.SharingNfsApi;

import java.io.File;
import java.util.*;

public class SharingNfsApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        SharingNfsApi apiInstance = new SharingNfsApi();
        Sharing_nfs_create_0 body = ; // Sharing_nfs_create_0 | 
        try {
            apiInstance.sharingNfsPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling SharingNfsApi#sharingNfsPost");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::SharingNfsApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::SharingNfsApi->new();
my $body = WWW::SwaggerClient::Object::Sharing_nfs_create_0->new(); # Sharing_nfs_create_0 | 

eval { 
    $api_instance->sharingNfsPost(body => $body);
};
if ($@) {
    warn "Exception when calling SharingNfsApi->sharingNfsPost: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.SharingNfsApi()
body =  # Sharing_nfs_create_0 |  (optional)

try: 
    api_instance.sharing_nfs_post(body=body)
except ApiException as e:
    print("Exception when calling SharingNfsApi->sharingNfsPost: %s\n" % e)

Parameters

Body parameters
Name Description
body

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


SharingSmb

sharingSmbGet


/sharing/smb

Usage and SDK Samples

curl -X GET -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/sharing/smb?limit=&offset=&count=&sort="
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.SharingSmbApi;

import java.io.File;
import java.util.*;

public class SharingSmbApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        SharingSmbApi apiInstance = new SharingSmbApi();
        Integer limit = 56; // Integer | 
        Integer offset = 56; // Integer | 
        Boolean count = true; // Boolean | 
        String sort = sort_example; // String | 
        try {
            apiInstance.sharingSmbGet(limit, offset, count, sort);
        } catch (ApiException e) {
            System.err.println("Exception when calling SharingSmbApi#sharingSmbGet");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::SharingSmbApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::SharingSmbApi->new();
my $limit = 56; # Integer | 
my $offset = 56; # Integer | 
my $count = true; # Boolean | 
my $sort = sort_example; # String | 

eval { 
    $api_instance->sharingSmbGet(limit => $limit, offset => $offset, count => $count, sort => $sort);
};
if ($@) {
    warn "Exception when calling SharingSmbApi->sharingSmbGet: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.SharingSmbApi()
limit = 56 # Integer |  (optional)
offset = 56 # Integer |  (optional)
count = true # Boolean |  (optional)
sort = sort_example # String |  (optional)

try: 
    api_instance.sharing_smb_get(limit=limit, offset=offset, count=count, sort=sort)
except ApiException as e:
    print("Exception when calling SharingSmbApi->sharingSmbGet: %s\n" % e)

Parameters

Query parameters
Name Description
limit
Integer
offset
Integer
count
Boolean
sort
String

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


sharingSmbIdIdDelete

Delete SMB Share of `id`. This will forcibly disconnect SMB clients that are accessing the share.


/sharing/smb/id/{id}

Usage and SDK Samples

curl -X DELETE -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/sharing/smb/id/{id}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.SharingSmbApi;

import java.io.File;
import java.util.*;

public class SharingSmbApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        SharingSmbApi apiInstance = new SharingSmbApi();
        Integer id = 56; // Integer | 
        try {
            apiInstance.sharingSmbIdIdDelete(id);
        } catch (ApiException e) {
            System.err.println("Exception when calling SharingSmbApi#sharingSmbIdIdDelete");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::SharingSmbApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::SharingSmbApi->new();
my $id = 56; # Integer | 

eval { 
    $api_instance->sharingSmbIdIdDelete(id => $id);
};
if ($@) {
    warn "Exception when calling SharingSmbApi->sharingSmbIdIdDelete: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.SharingSmbApi()
id = 56 # Integer | 

try: 
    api_instance.sharing_smb_id_id_delete(id)
except ApiException as e:
    print("Exception when calling SharingSmbApi->sharingSmbIdIdDelete: %s\n" % e)

Parameters

Path parameters
Name Description
id*
Integer
Required

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


sharingSmbIdIdGet


/sharing/smb/id/{id}

Usage and SDK Samples

curl -X GET -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/sharing/smb/id/{id}?limit=&offset=&count=&sort="
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.SharingSmbApi;

import java.io.File;
import java.util.*;

public class SharingSmbApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        SharingSmbApi apiInstance = new SharingSmbApi();
        array[null] id = ; // array[null] | 
        Integer limit = 56; // Integer | 
        Integer offset = 56; // Integer | 
        Boolean count = true; // Boolean | 
        String sort = sort_example; // String | 
        try {
            apiInstance.sharingSmbIdIdGet(id, limit, offset, count, sort);
        } catch (ApiException e) {
            System.err.println("Exception when calling SharingSmbApi#sharingSmbIdIdGet");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::SharingSmbApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::SharingSmbApi->new();
my $id = []; # array[null] | 
my $limit = 56; # Integer | 
my $offset = 56; # Integer | 
my $count = true; # Boolean | 
my $sort = sort_example; # String | 

eval { 
    $api_instance->sharingSmbIdIdGet(id => $id, limit => $limit, offset => $offset, count => $count, sort => $sort);
};
if ($@) {
    warn "Exception when calling SharingSmbApi->sharingSmbIdIdGet: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.SharingSmbApi()
id =  # array[null] | 
limit = 56 # Integer |  (optional)
offset = 56 # Integer |  (optional)
count = true # Boolean |  (optional)
sort = sort_example # String |  (optional)

try: 
    api_instance.sharing_smb_id_id_get(id, limit=limit, offset=offset, count=count, sort=sort)
except ApiException as e:
    print("Exception when calling SharingSmbApi->sharingSmbIdIdGet: %s\n" % e)

Parameters

Path parameters
Name Description
id*
array[null]
Required
Query parameters
Name Description
limit
Integer
offset
Integer
count
Boolean
sort
String

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


sharingSmbIdIdPut

Update SMB Share of `id`.


/sharing/smb/id/{id}

Usage and SDK Samples

curl -X PUT -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/sharing/smb/id/{id}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.SharingSmbApi;

import java.io.File;
import java.util.*;

public class SharingSmbApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        SharingSmbApi apiInstance = new SharingSmbApi();
        Integer id = 56; // Integer | 
        Sharing_smb_update_1 body = ; // Sharing_smb_update_1 | 
        try {
            apiInstance.sharingSmbIdIdPut(id, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling SharingSmbApi#sharingSmbIdIdPut");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::SharingSmbApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::SharingSmbApi->new();
my $id = 56; # Integer | 
my $body = WWW::SwaggerClient::Object::Sharing_smb_update_1->new(); # Sharing_smb_update_1 | 

eval { 
    $api_instance->sharingSmbIdIdPut(id => $id, body => $body);
};
if ($@) {
    warn "Exception when calling SharingSmbApi->sharingSmbIdIdPut: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.SharingSmbApi()
id = 56 # Integer | 
body =  # Sharing_smb_update_1 |  (optional)

try: 
    api_instance.sharing_smb_id_id_put(id, body=body)
except ApiException as e:
    print("Exception when calling SharingSmbApi->sharingSmbIdIdPut: %s\n" % e)

Parameters

Path parameters
Name Description
id*
Integer
Required
Body parameters
Name Description
body

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


sharingSmbPost

Create a SMB Share. `purpose` applies common configuration presets depending on intended purpose. `timemachine` when set, enables Time Machine backups for this share. `ro` when enabled, prohibits write access to the share. `guestok` when enabled, allows access to this share without a password. `hostsallow` is a list of hostnames / IP addresses which have access to this share. `hostsdeny` is a list of hostnames / IP addresses which are not allowed access to this share. If a handful of hostnames are to be only allowed access, `hostsdeny` can be passed "ALL" which means that it will deny access to ALL hostnames except for the ones which have been listed in `hostsallow`. `acl` enables support for storing the SMB Security Descriptor as a Filesystem ACL. `streams` enables support for storing alternate datastreams as filesystem extended attributes. `fsrvp` enables support for the filesystem remote VSS protocol. This allows clients to create ZFS snapshots through RPC. `shadowcopy` enables support for the volume shadow copy service. `auxsmbconf` is a string of additional smb4.conf parameters not covered by the system's API.


/sharing/smb

Usage and SDK Samples

curl -X POST -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/sharing/smb"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.SharingSmbApi;

import java.io.File;
import java.util.*;

public class SharingSmbApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        SharingSmbApi apiInstance = new SharingSmbApi();
        Sharing_smb_create_0 body = ; // Sharing_smb_create_0 | 
        try {
            apiInstance.sharingSmbPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling SharingSmbApi#sharingSmbPost");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::SharingSmbApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::SharingSmbApi->new();
my $body = WWW::SwaggerClient::Object::Sharing_smb_create_0->new(); # Sharing_smb_create_0 | 

eval { 
    $api_instance->sharingSmbPost(body => $body);
};
if ($@) {
    warn "Exception when calling SharingSmbApi->sharingSmbPost: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.SharingSmbApi()
body =  # Sharing_smb_create_0 |  (optional)

try: 
    api_instance.sharing_smb_post(body=body)
except ApiException as e:
    print("Exception when calling SharingSmbApi->sharingSmbPost: %s\n" % e)

Parameters

Body parameters
Name Description
body

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


sharingSmbPresetsGet

Retrieve pre-defined configuration sets for specific use-cases. These parameter combinations are often non-obvious, but beneficial in these scenarios.


/sharing/smb/presets

Usage and SDK Samples

curl -X GET -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/sharing/smb/presets"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.SharingSmbApi;

import java.io.File;
import java.util.*;

public class SharingSmbApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        SharingSmbApi apiInstance = new SharingSmbApi();
        try {
            apiInstance.sharingSmbPresetsGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling SharingSmbApi#sharingSmbPresetsGet");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::SharingSmbApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::SharingSmbApi->new();

eval { 
    $api_instance->sharingSmbPresetsGet();
};
if ($@) {
    warn "Exception when calling SharingSmbApi->sharingSmbPresetsGet: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.SharingSmbApi()

try: 
    api_instance.sharing_smb_presets_get()
except ApiException as e:
    print("Exception when calling SharingSmbApi->sharingSmbPresetsGet: %s\n" % e)

Parameters

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


SharingWebdav

sharingWebdavGet


/sharing/webdav

Usage and SDK Samples

curl -X GET -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/sharing/webdav?limit=&offset=&count=&sort="
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.SharingWebdavApi;

import java.io.File;
import java.util.*;

public class SharingWebdavApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        SharingWebdavApi apiInstance = new SharingWebdavApi();
        Integer limit = 56; // Integer | 
        Integer offset = 56; // Integer | 
        Boolean count = true; // Boolean | 
        String sort = sort_example; // String | 
        try {
            apiInstance.sharingWebdavGet(limit, offset, count, sort);
        } catch (ApiException e) {
            System.err.println("Exception when calling SharingWebdavApi#sharingWebdavGet");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::SharingWebdavApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::SharingWebdavApi->new();
my $limit = 56; # Integer | 
my $offset = 56; # Integer | 
my $count = true; # Boolean | 
my $sort = sort_example; # String | 

eval { 
    $api_instance->sharingWebdavGet(limit => $limit, offset => $offset, count => $count, sort => $sort);
};
if ($@) {
    warn "Exception when calling SharingWebdavApi->sharingWebdavGet: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.SharingWebdavApi()
limit = 56 # Integer |  (optional)
offset = 56 # Integer |  (optional)
count = true # Boolean |  (optional)
sort = sort_example # String |  (optional)

try: 
    api_instance.sharing_webdav_get(limit=limit, offset=offset, count=count, sort=sort)
except ApiException as e:
    print("Exception when calling SharingWebdavApi->sharingWebdavGet: %s\n" % e)

Parameters

Query parameters
Name Description
limit
Integer
offset
Integer
count
Boolean
sort
String

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


sharingWebdavIdIdDelete

Update Webdav Share of `id`.


/sharing/webdav/id/{id}

Usage and SDK Samples

curl -X DELETE -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/sharing/webdav/id/{id}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.SharingWebdavApi;

import java.io.File;
import java.util.*;

public class SharingWebdavApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        SharingWebdavApi apiInstance = new SharingWebdavApi();
        Integer id = 56; // Integer | 
        try {
            apiInstance.sharingWebdavIdIdDelete(id);
        } catch (ApiException e) {
            System.err.println("Exception when calling SharingWebdavApi#sharingWebdavIdIdDelete");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::SharingWebdavApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::SharingWebdavApi->new();
my $id = 56; # Integer | 

eval { 
    $api_instance->sharingWebdavIdIdDelete(id => $id);
};
if ($@) {
    warn "Exception when calling SharingWebdavApi->sharingWebdavIdIdDelete: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.SharingWebdavApi()
id = 56 # Integer | 

try: 
    api_instance.sharing_webdav_id_id_delete(id)
except ApiException as e:
    print("Exception when calling SharingWebdavApi->sharingWebdavIdIdDelete: %s\n" % e)

Parameters

Path parameters
Name Description
id*
Integer
Required

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


sharingWebdavIdIdGet


/sharing/webdav/id/{id}

Usage and SDK Samples

curl -X GET -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/sharing/webdav/id/{id}?limit=&offset=&count=&sort="
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.SharingWebdavApi;

import java.io.File;
import java.util.*;

public class SharingWebdavApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        SharingWebdavApi apiInstance = new SharingWebdavApi();
        array[null] id = ; // array[null] | 
        Integer limit = 56; // Integer | 
        Integer offset = 56; // Integer | 
        Boolean count = true; // Boolean | 
        String sort = sort_example; // String | 
        try {
            apiInstance.sharingWebdavIdIdGet(id, limit, offset, count, sort);
        } catch (ApiException e) {
            System.err.println("Exception when calling SharingWebdavApi#sharingWebdavIdIdGet");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::SharingWebdavApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::SharingWebdavApi->new();
my $id = []; # array[null] | 
my $limit = 56; # Integer | 
my $offset = 56; # Integer | 
my $count = true; # Boolean | 
my $sort = sort_example; # String | 

eval { 
    $api_instance->sharingWebdavIdIdGet(id => $id, limit => $limit, offset => $offset, count => $count, sort => $sort);
};
if ($@) {
    warn "Exception when calling SharingWebdavApi->sharingWebdavIdIdGet: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.SharingWebdavApi()
id =  # array[null] | 
limit = 56 # Integer |  (optional)
offset = 56 # Integer |  (optional)
count = true # Boolean |  (optional)
sort = sort_example # String |  (optional)

try: 
    api_instance.sharing_webdav_id_id_get(id, limit=limit, offset=offset, count=count, sort=sort)
except ApiException as e:
    print("Exception when calling SharingWebdavApi->sharingWebdavIdIdGet: %s\n" % e)

Parameters

Path parameters
Name Description
id*
array[null]
Required
Query parameters
Name Description
limit
Integer
offset
Integer
count
Boolean
sort
String

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


sharingWebdavIdIdPut

Update Webdav Share of `id`.


/sharing/webdav/id/{id}

Usage and SDK Samples

curl -X PUT -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/sharing/webdav/id/{id}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.SharingWebdavApi;

import java.io.File;
import java.util.*;

public class SharingWebdavApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        SharingWebdavApi apiInstance = new SharingWebdavApi();
        Integer id = 56; // Integer | 
        Sharing_webdav_update_1 body = ; // Sharing_webdav_update_1 | 
        try {
            apiInstance.sharingWebdavIdIdPut(id, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling SharingWebdavApi#sharingWebdavIdIdPut");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::SharingWebdavApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::SharingWebdavApi->new();
my $id = 56; # Integer | 
my $body = WWW::SwaggerClient::Object::Sharing_webdav_update_1->new(); # Sharing_webdav_update_1 | 

eval { 
    $api_instance->sharingWebdavIdIdPut(id => $id, body => $body);
};
if ($@) {
    warn "Exception when calling SharingWebdavApi->sharingWebdavIdIdPut: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.SharingWebdavApi()
id = 56 # Integer | 
body =  # Sharing_webdav_update_1 |  (optional)

try: 
    api_instance.sharing_webdav_id_id_put(id, body=body)
except ApiException as e:
    print("Exception when calling SharingWebdavApi->sharingWebdavIdIdPut: %s\n" % e)

Parameters

Path parameters
Name Description
id*
Integer
Required
Body parameters
Name Description
body

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


sharingWebdavPost

Create a Webdav Share. `ro` when enabled prohibits users from writing to this share. `perm` when enabled automatically recursively changes the ownership of this share to webdav ( user and group both ).


/sharing/webdav

Usage and SDK Samples

curl -X POST -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/sharing/webdav"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.SharingWebdavApi;

import java.io.File;
import java.util.*;

public class SharingWebdavApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        SharingWebdavApi apiInstance = new SharingWebdavApi();
        Sharing_webdav_create_0 body = ; // Sharing_webdav_create_0 | 
        try {
            apiInstance.sharingWebdavPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling SharingWebdavApi#sharingWebdavPost");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::SharingWebdavApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::SharingWebdavApi->new();
my $body = WWW::SwaggerClient::Object::Sharing_webdav_create_0->new(); # Sharing_webdav_create_0 | 

eval { 
    $api_instance->sharingWebdavPost(body => $body);
};
if ($@) {
    warn "Exception when calling SharingWebdavApi->sharingWebdavPost: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.SharingWebdavApi()
body =  # Sharing_webdav_create_0 |  (optional)

try: 
    api_instance.sharing_webdav_post(body=body)
except ApiException as e:
    print("Exception when calling SharingWebdavApi->sharingWebdavPost: %s\n" % e)

Parameters

Body parameters
Name Description
body

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


Smart

smartGet


/smart

Usage and SDK Samples

curl -X GET -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/smart"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.SmartApi;

import java.io.File;
import java.util.*;

public class SmartApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        SmartApi apiInstance = new SmartApi();
        try {
            apiInstance.smartGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling SmartApi#smartGet");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::SmartApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::SmartApi->new();

eval { 
    $api_instance->smartGet();
};
if ($@) {
    warn "Exception when calling SmartApi->smartGet: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.SmartApi()

try: 
    api_instance.smart_get()
except ApiException as e:
    print("Exception when calling SmartApi->smartGet: %s\n" % e)

Parameters

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


smartPut

Update SMART Service Configuration. `interval` is an integer value in minutes which defines how often smartd activates to check if any tests are configured to run. `critical`, `informational` and `difference` are integer values on which alerts for SMART are configured if the disks temperature crosses the assigned threshold for each respective attribute. They default to 0 which indicates they are disabled.


/smart

Usage and SDK Samples

curl -X PUT -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/smart"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.SmartApi;

import java.io.File;
import java.util.*;

public class SmartApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        SmartApi apiInstance = new SmartApi();
        Smart_update_0 body = ; // Smart_update_0 | 
        try {
            apiInstance.smartPut(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling SmartApi#smartPut");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::SmartApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::SmartApi->new();
my $body = WWW::SwaggerClient::Object::Smart_update_0->new(); # Smart_update_0 | 

eval { 
    $api_instance->smartPut(body => $body);
};
if ($@) {
    warn "Exception when calling SmartApi->smartPut: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.SmartApi()
body =  # Smart_update_0 |  (optional)

try: 
    api_instance.smart_put(body=body)
except ApiException as e:
    print("Exception when calling SmartApi->smartPut: %s\n" % e)

Parameters

Body parameters
Name Description
body

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


SmartTest

smartTestGet


/smart/test

Usage and SDK Samples

curl -X GET -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/smart/test?limit=&offset=&count=&sort="
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.SmartTestApi;

import java.io.File;
import java.util.*;

public class SmartTestApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        SmartTestApi apiInstance = new SmartTestApi();
        Integer limit = 56; // Integer | 
        Integer offset = 56; // Integer | 
        Boolean count = true; // Boolean | 
        String sort = sort_example; // String | 
        try {
            apiInstance.smartTestGet(limit, offset, count, sort);
        } catch (ApiException e) {
            System.err.println("Exception when calling SmartTestApi#smartTestGet");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::SmartTestApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::SmartTestApi->new();
my $limit = 56; # Integer | 
my $offset = 56; # Integer | 
my $count = true; # Boolean | 
my $sort = sort_example; # String | 

eval { 
    $api_instance->smartTestGet(limit => $limit, offset => $offset, count => $count, sort => $sort);
};
if ($@) {
    warn "Exception when calling SmartTestApi->smartTestGet: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.SmartTestApi()
limit = 56 # Integer |  (optional)
offset = 56 # Integer |  (optional)
count = true # Boolean |  (optional)
sort = sort_example # String |  (optional)

try: 
    api_instance.smart_test_get(limit=limit, offset=offset, count=count, sort=sort)
except ApiException as e:
    print("Exception when calling SmartTestApi->smartTestGet: %s\n" % e)

Parameters

Query parameters
Name Description
limit
Integer
offset
Integer
count
Boolean
sort
String

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


smartTestIdIdDelete

Delete SMART Test Task of `id`.


/smart/test/id/{id}

Usage and SDK Samples

curl -X DELETE -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/smart/test/id/{id}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.SmartTestApi;

import java.io.File;
import java.util.*;

public class SmartTestApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        SmartTestApi apiInstance = new SmartTestApi();
        Integer id = 56; // Integer | 
        try {
            apiInstance.smartTestIdIdDelete(id);
        } catch (ApiException e) {
            System.err.println("Exception when calling SmartTestApi#smartTestIdIdDelete");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::SmartTestApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::SmartTestApi->new();
my $id = 56; # Integer | 

eval { 
    $api_instance->smartTestIdIdDelete(id => $id);
};
if ($@) {
    warn "Exception when calling SmartTestApi->smartTestIdIdDelete: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.SmartTestApi()
id = 56 # Integer | 

try: 
    api_instance.smart_test_id_id_delete(id)
except ApiException as e:
    print("Exception when calling SmartTestApi->smartTestIdIdDelete: %s\n" % e)

Parameters

Path parameters
Name Description
id*
Integer
Required

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


smartTestIdIdGet


/smart/test/id/{id}

Usage and SDK Samples

curl -X GET -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/smart/test/id/{id}?limit=&offset=&count=&sort="
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.SmartTestApi;

import java.io.File;
import java.util.*;

public class SmartTestApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        SmartTestApi apiInstance = new SmartTestApi();
        array[null] id = ; // array[null] | 
        Integer limit = 56; // Integer | 
        Integer offset = 56; // Integer | 
        Boolean count = true; // Boolean | 
        String sort = sort_example; // String | 
        try {
            apiInstance.smartTestIdIdGet(id, limit, offset, count, sort);
        } catch (ApiException e) {
            System.err.println("Exception when calling SmartTestApi#smartTestIdIdGet");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::SmartTestApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::SmartTestApi->new();
my $id = []; # array[null] | 
my $limit = 56; # Integer | 
my $offset = 56; # Integer | 
my $count = true; # Boolean | 
my $sort = sort_example; # String | 

eval { 
    $api_instance->smartTestIdIdGet(id => $id, limit => $limit, offset => $offset, count => $count, sort => $sort);
};
if ($@) {
    warn "Exception when calling SmartTestApi->smartTestIdIdGet: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.SmartTestApi()
id =  # array[null] | 
limit = 56 # Integer |  (optional)
offset = 56 # Integer |  (optional)
count = true # Boolean |  (optional)
sort = sort_example # String |  (optional)

try: 
    api_instance.smart_test_id_id_get(id, limit=limit, offset=offset, count=count, sort=sort)
except ApiException as e:
    print("Exception when calling SmartTestApi->smartTestIdIdGet: %s\n" % e)

Parameters

Path parameters
Name Description
id*
array[null]
Required
Query parameters
Name Description
limit
Integer
offset
Integer
count
Boolean
sort
String

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


smartTestIdIdPut

Update SMART Test Task of `id`.


/smart/test/id/{id}

Usage and SDK Samples

curl -X PUT -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/smart/test/id/{id}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.SmartTestApi;

import java.io.File;
import java.util.*;

public class SmartTestApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        SmartTestApi apiInstance = new SmartTestApi();
        Integer id = 56; // Integer | 
        Smart_test_update_1 body = ; // Smart_test_update_1 | 
        try {
            apiInstance.smartTestIdIdPut(id, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling SmartTestApi#smartTestIdIdPut");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::SmartTestApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::SmartTestApi->new();
my $id = 56; # Integer | 
my $body = WWW::SwaggerClient::Object::Smart_test_update_1->new(); # Smart_test_update_1 | 

eval { 
    $api_instance->smartTestIdIdPut(id => $id, body => $body);
};
if ($@) {
    warn "Exception when calling SmartTestApi->smartTestIdIdPut: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.SmartTestApi()
id = 56 # Integer | 
body =  # Smart_test_update_1 |  (optional)

try: 
    api_instance.smart_test_id_id_put(id, body=body)
except ApiException as e:
    print("Exception when calling SmartTestApi->smartTestIdIdPut: %s\n" % e)

Parameters

Path parameters
Name Description
id*
Integer
Required
Body parameters
Name Description
body

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


smartTestManualTestPost

Run manual SMART tests for `disks`. `type` indicates what type of SMART test will be ran and must be specified.


/smart/test/manual_test

Usage and SDK Samples

curl -X POST -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/smart/test/manual_test"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.SmartTestApi;

import java.io.File;
import java.util.*;

public class SmartTestApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        SmartTestApi apiInstance = new SmartTestApi();
        array[Object] body = ; // array[Object] | 
        try {
            apiInstance.smartTestManualTestPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling SmartTestApi#smartTestManualTestPost");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::SmartTestApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::SmartTestApi->new();
my $body = [WWW::SwaggerClient::Object::array[Object]->new()]; # array[Object] | 

eval { 
    $api_instance->smartTestManualTestPost(body => $body);
};
if ($@) {
    warn "Exception when calling SmartTestApi->smartTestManualTestPost: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.SmartTestApi()
body =  # array[Object] |  (optional)

try: 
    api_instance.smart_test_manual_test_post(body=body)
except ApiException as e:
    print("Exception when calling SmartTestApi->smartTestManualTestPost: %s\n" % e)

Parameters

Body parameters
Name Description
body

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


smartTestPost

Create a SMART Test Task. `disks` is a list of valid disks which should be monitored in this task. `type` is specified to represent the type of SMART test to be executed. `all_disks` when enabled sets the task to cover all disks in which case `disks` is not required.


/smart/test

Usage and SDK Samples

curl -X POST -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/smart/test"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.SmartTestApi;

import java.io.File;
import java.util.*;

public class SmartTestApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        SmartTestApi apiInstance = new SmartTestApi();
        Smart_test_create_0 body = ; // Smart_test_create_0 | 
        try {
            apiInstance.smartTestPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling SmartTestApi#smartTestPost");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::SmartTestApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::SmartTestApi->new();
my $body = WWW::SwaggerClient::Object::Smart_test_create_0->new(); # Smart_test_create_0 | 

eval { 
    $api_instance->smartTestPost(body => $body);
};
if ($@) {
    warn "Exception when calling SmartTestApi->smartTestPost: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.SmartTestApi()
body =  # Smart_test_create_0 |  (optional)

try: 
    api_instance.smart_test_post(body=body)
except ApiException as e:
    print("Exception when calling SmartTestApi->smartTestPost: %s\n" % e)

Parameters

Body parameters
Name Description
body

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


smartTestResultsGet

Get disk(s) S.M.A.R.T. test(s) results.


/smart/test/results

Usage and SDK Samples

curl -X GET -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/smart/test/results?limit=&offset=&count=&sort="
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.SmartTestApi;

import java.io.File;
import java.util.*;

public class SmartTestApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        SmartTestApi apiInstance = new SmartTestApi();
        Integer limit = 56; // Integer | 
        Integer offset = 56; // Integer | 
        Boolean count = true; // Boolean | 
        String sort = sort_example; // String | 
        try {
            apiInstance.smartTestResultsGet(limit, offset, count, sort);
        } catch (ApiException e) {
            System.err.println("Exception when calling SmartTestApi#smartTestResultsGet");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::SmartTestApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::SmartTestApi->new();
my $limit = 56; # Integer | 
my $offset = 56; # Integer | 
my $count = true; # Boolean | 
my $sort = sort_example; # String | 

eval { 
    $api_instance->smartTestResultsGet(limit => $limit, offset => $offset, count => $count, sort => $sort);
};
if ($@) {
    warn "Exception when calling SmartTestApi->smartTestResultsGet: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.SmartTestApi()
limit = 56 # Integer |  (optional)
offset = 56 # Integer |  (optional)
count = true # Boolean |  (optional)
sort = sort_example # String |  (optional)

try: 
    api_instance.smart_test_results_get(limit=limit, offset=offset, count=count, sort=sort)
except ApiException as e:
    print("Exception when calling SmartTestApi->smartTestResultsGet: %s\n" % e)

Parameters

Query parameters
Name Description
limit
Integer
offset
Integer
count
Boolean
sort
String

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


Smb

smbBindipChoicesGet

List of valid choices for IP addresses to which to bind the SMB service. Addresses assigned by DHCP are excluded from the results.


/smb/bindip_choices

Usage and SDK Samples

curl -X GET -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/smb/bindip_choices"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.SmbApi;

import java.io.File;
import java.util.*;

public class SmbApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        SmbApi apiInstance = new SmbApi();
        try {
            apiInstance.smbBindipChoicesGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling SmbApi#smbBindipChoicesGet");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::SmbApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::SmbApi->new();

eval { 
    $api_instance->smbBindipChoicesGet();
};
if ($@) {
    warn "Exception when calling SmbApi->smbBindipChoicesGet: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.SmbApi()

try: 
    api_instance.smb_bindip_choices_get()
except ApiException as e:
    print("Exception when calling SmbApi->smbBindipChoicesGet: %s\n" % e)

Parameters

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


smbDomainChoicesGet

List of domains visible to winbindd. Returns empty list if winbindd is stopped.


/smb/domain_choices

Usage and SDK Samples

curl -X GET -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/smb/domain_choices"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.SmbApi;

import java.io.File;
import java.util.*;

public class SmbApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        SmbApi apiInstance = new SmbApi();
        try {
            apiInstance.smbDomainChoicesGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling SmbApi#smbDomainChoicesGet");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::SmbApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::SmbApi->new();

eval { 
    $api_instance->smbDomainChoicesGet();
};
if ($@) {
    warn "Exception when calling SmbApi->smbDomainChoicesGet: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.SmbApi()

try: 
    api_instance.smb_domain_choices_get()
except ApiException as e:
    print("Exception when calling SmbApi->smbDomainChoicesGet: %s\n" % e)

Parameters

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


smbGet


/smb

Usage and SDK Samples

curl -X GET -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/smb"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.SmbApi;

import java.io.File;
import java.util.*;

public class SmbApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        SmbApi apiInstance = new SmbApi();
        try {
            apiInstance.smbGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling SmbApi#smbGet");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::SmbApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::SmbApi->new();

eval { 
    $api_instance->smbGet();
};
if ($@) {
    warn "Exception when calling SmbApi->smbGet: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.SmbApi()

try: 
    api_instance.smb_get()
except ApiException as e:
    print("Exception when calling SmbApi->smbGet: %s\n" % e)

Parameters

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


smbGetRemoteAclPost

Retrieves an ACL from a remote SMB server. `server` IP Address or hostname of the remote server `share` Share name `path` path on the remote SMB server. Use "" to separate path components `username` username to use for authentication `password` password to use for authentication `use_kerberos` use credentials to get a kerberos ticket for authentication. AD only. `output_format` format for resulting ACL data. Choices are either 'SMB', which will present the information as a Windows SD or 'LOCAL', which formats the ACL information according local filesystem of the TrueNAS server.


/smb/get_remote_acl

Usage and SDK Samples

curl -X POST -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/smb/get_remote_acl"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.SmbApi;

import java.io.File;
import java.util.*;

public class SmbApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        SmbApi apiInstance = new SmbApi();
        Smb_get_remote_acl_0 body = ; // Smb_get_remote_acl_0 | 
        try {
            apiInstance.smbGetRemoteAclPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling SmbApi#smbGetRemoteAclPost");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::SmbApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::SmbApi->new();
my $body = WWW::SwaggerClient::Object::Smb_get_remote_acl_0->new(); # Smb_get_remote_acl_0 | 

eval { 
    $api_instance->smbGetRemoteAclPost(body => $body);
};
if ($@) {
    warn "Exception when calling SmbApi->smbGetRemoteAclPost: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.SmbApi()
body =  # Smb_get_remote_acl_0 |  (optional)

try: 
    api_instance.smb_get_remote_acl_post(body=body)
except ApiException as e:
    print("Exception when calling SmbApi->smbGetRemoteAclPost: %s\n" % e)

Parameters

Body parameters
Name Description
body

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


smbPut

Update SMB Service Configuration. `netbiosname` defaults to the original hostname of the system. `workgroup` and `netbiosname` should have different values. `enable_smb1` allows legacy SMB clients to connect to the server when enabled. `localmaster` when set, determines if the system participates in a browser election. `domain_logons` is used to provide netlogin service for older Windows clients if enabled. `guest` attribute is specified to select the account to be used for guest access. It defaults to "nobody". `nullpw` when enabled allows the users to authorize access without a password. `hostlookup` when enabled, allows using hostnames rather then IP addresses in "hostsallow"/"hostsdeny" fields of SMB Shares.


/smb

Usage and SDK Samples

curl -X PUT -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/smb"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.SmbApi;

import java.io.File;
import java.util.*;

public class SmbApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        SmbApi apiInstance = new SmbApi();
        Smb_update_0 body = ; // Smb_update_0 | 
        try {
            apiInstance.smbPut(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling SmbApi#smbPut");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::SmbApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::SmbApi->new();
my $body = WWW::SwaggerClient::Object::Smb_update_0->new(); # Smb_update_0 | 

eval { 
    $api_instance->smbPut(body => $body);
};
if ($@) {
    warn "Exception when calling SmbApi->smbPut: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.SmbApi()
body =  # Smb_update_0 |  (optional)

try: 
    api_instance.smb_put(body=body)
except ApiException as e:
    print("Exception when calling SmbApi->smbPut: %s\n" % e)

Parameters

Body parameters
Name Description
body

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


smbStatusPost

Returns SMB server status (sessions, open files, locks, notifications). `info_level` type of information requests. Defaults to ALL. `status_options` additional options to filter query results. Supported values are as follows: `verbose` gives more verbose status output `fast` causes smbstatus to not check if the status data is valid by checking if the processes that the status data refer to all still exist. This speeds up execution on busy systems and clusters but might display stale data of processes that died without cleaning up properly. `restrict_user` specifies the limits results to the specified user.


/smb/status

Usage and SDK Samples

curl -X POST -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/smb/status"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.SmbApi;

import java.io.File;
import java.util.*;

public class SmbApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        SmbApi apiInstance = new SmbApi();
        Smb_status body = ; // Smb_status | 
        try {
            apiInstance.smbStatusPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling SmbApi#smbStatusPost");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::SmbApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::SmbApi->new();
my $body = WWW::SwaggerClient::Object::Smb_status->new(); # Smb_status | 

eval { 
    $api_instance->smbStatusPost(body => $body);
};
if ($@) {
    warn "Exception when calling SmbApi->smbStatusPost: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.SmbApi()
body =  # Smb_status |  (optional)

try: 
    api_instance.smb_status_post(body=body)
except ApiException as e:
    print("Exception when calling SmbApi->smbStatusPost: %s\n" % e)

Parameters

Body parameters
Name Description
body

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


smbUnixcharsetChoicesGet


/smb/unixcharset_choices

Usage and SDK Samples

curl -X GET -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/smb/unixcharset_choices"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.SmbApi;

import java.io.File;
import java.util.*;

public class SmbApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        SmbApi apiInstance = new SmbApi();
        try {
            apiInstance.smbUnixcharsetChoicesGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling SmbApi#smbUnixcharsetChoicesGet");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::SmbApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::SmbApi->new();

eval { 
    $api_instance->smbUnixcharsetChoicesGet();
};
if ($@) {
    warn "Exception when calling SmbApi->smbUnixcharsetChoicesGet: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.SmbApi()

try: 
    api_instance.smb_unixcharset_choices_get()
except ApiException as e:
    print("Exception when calling SmbApi->smbUnixcharsetChoicesGet: %s\n" % e)

Parameters

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


SmbSharesec

smbSharesecGet

Use query-filters to search the SMB share ACLs present on server.


/smb/sharesec

Usage and SDK Samples

curl -X GET -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/smb/sharesec?limit=&offset=&count=&sort="
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.SmbSharesecApi;

import java.io.File;
import java.util.*;

public class SmbSharesecApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        SmbSharesecApi apiInstance = new SmbSharesecApi();
        Integer limit = 56; // Integer | 
        Integer offset = 56; // Integer | 
        Boolean count = true; // Boolean | 
        String sort = sort_example; // String | 
        try {
            apiInstance.smbSharesecGet(limit, offset, count, sort);
        } catch (ApiException e) {
            System.err.println("Exception when calling SmbSharesecApi#smbSharesecGet");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::SmbSharesecApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::SmbSharesecApi->new();
my $limit = 56; # Integer | 
my $offset = 56; # Integer | 
my $count = true; # Boolean | 
my $sort = sort_example; # String | 

eval { 
    $api_instance->smbSharesecGet(limit => $limit, offset => $offset, count => $count, sort => $sort);
};
if ($@) {
    warn "Exception when calling SmbSharesecApi->smbSharesecGet: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.SmbSharesecApi()
limit = 56 # Integer |  (optional)
offset = 56 # Integer |  (optional)
count = true # Boolean |  (optional)
sort = sort_example # String |  (optional)

try: 
    api_instance.smb_sharesec_get(limit=limit, offset=offset, count=count, sort=sort)
except ApiException as e:
    print("Exception when calling SmbSharesecApi->smbSharesecGet: %s\n" % e)

Parameters

Query parameters
Name Description
limit
Integer
offset
Integer
count
Boolean
sort
String

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


smbSharesecGetaclPost

View the ACL information for `share_name`. The share ACL is distinct from filesystem ACLs which can be viewed by calling `filesystem.getacl`. `ae_who_name` will appear as `None` if the SMB service is stopped or if winbind is unable to resolve the SID to a name. If the `option` `resolve_sids` is set to `False` then the returned ACL will not contain names.


/smb/sharesec/getacl

Usage and SDK Samples

curl -X POST -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/smb/sharesec/getacl"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.SmbSharesecApi;

import java.io.File;
import java.util.*;

public class SmbSharesecApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        SmbSharesecApi apiInstance = new SmbSharesecApi();
        Smb_sharesec_getacl body = ; // Smb_sharesec_getacl | 
        try {
            apiInstance.smbSharesecGetaclPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling SmbSharesecApi#smbSharesecGetaclPost");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::SmbSharesecApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::SmbSharesecApi->new();
my $body = WWW::SwaggerClient::Object::Smb_sharesec_getacl->new(); # Smb_sharesec_getacl | 

eval { 
    $api_instance->smbSharesecGetaclPost(body => $body);
};
if ($@) {
    warn "Exception when calling SmbSharesecApi->smbSharesecGetaclPost: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.SmbSharesecApi()
body =  # Smb_sharesec_getacl |  (optional)

try: 
    api_instance.smb_sharesec_getacl_post(body=body)
except ApiException as e:
    print("Exception when calling SmbSharesecApi->smbSharesecGetaclPost: %s\n" % e)

Parameters

Body parameters
Name Description
body

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


smbSharesecIdIdDelete

Replace share ACL for the specified SMB share with the samba default ACL of S-1-1-0/FULL (Everyone - Full Control). In this case, access will be fully determined by the underlying filesystem ACLs and smb4.conf parameters governing access control and permissions. Share can be deleted by name or numerical by numerical index.


/smb/sharesec/id/{id}

Usage and SDK Samples

curl -X DELETE -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/smb/sharesec/id/{id}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.SmbSharesecApi;

import java.io.File;
import java.util.*;

public class SmbSharesecApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        SmbSharesecApi apiInstance = new SmbSharesecApi();
        String id = id_example; // String | 
        try {
            apiInstance.smbSharesecIdIdDelete(id);
        } catch (ApiException e) {
            System.err.println("Exception when calling SmbSharesecApi#smbSharesecIdIdDelete");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::SmbSharesecApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::SmbSharesecApi->new();
my $id = id_example; # String | 

eval { 
    $api_instance->smbSharesecIdIdDelete(id => $id);
};
if ($@) {
    warn "Exception when calling SmbSharesecApi->smbSharesecIdIdDelete: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.SmbSharesecApi()
id = id_example # String | 

try: 
    api_instance.smb_sharesec_id_id_delete(id)
except ApiException as e:
    print("Exception when calling SmbSharesecApi->smbSharesecIdIdDelete: %s\n" % e)

Parameters

Path parameters
Name Description
id*
String
Required

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


smbSharesecIdIdGet

Use query-filters to search the SMB share ACLs present on server.


/smb/sharesec/id/{id}

Usage and SDK Samples

curl -X GET -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/smb/sharesec/id/{id}?limit=&offset=&count=&sort="
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.SmbSharesecApi;

import java.io.File;
import java.util.*;

public class SmbSharesecApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        SmbSharesecApi apiInstance = new SmbSharesecApi();
        array[null] id = ; // array[null] | 
        Integer limit = 56; // Integer | 
        Integer offset = 56; // Integer | 
        Boolean count = true; // Boolean | 
        String sort = sort_example; // String | 
        try {
            apiInstance.smbSharesecIdIdGet(id, limit, offset, count, sort);
        } catch (ApiException e) {
            System.err.println("Exception when calling SmbSharesecApi#smbSharesecIdIdGet");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::SmbSharesecApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::SmbSharesecApi->new();
my $id = []; # array[null] | 
my $limit = 56; # Integer | 
my $offset = 56; # Integer | 
my $count = true; # Boolean | 
my $sort = sort_example; # String | 

eval { 
    $api_instance->smbSharesecIdIdGet(id => $id, limit => $limit, offset => $offset, count => $count, sort => $sort);
};
if ($@) {
    warn "Exception when calling SmbSharesecApi->smbSharesecIdIdGet: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.SmbSharesecApi()
id =  # array[null] | 
limit = 56 # Integer |  (optional)
offset = 56 # Integer |  (optional)
count = true # Boolean |  (optional)
sort = sort_example # String |  (optional)

try: 
    api_instance.smb_sharesec_id_id_get(id, limit=limit, offset=offset, count=count, sort=sort)
except ApiException as e:
    print("Exception when calling SmbSharesecApi->smbSharesecIdIdGet: %s\n" % e)

Parameters

Path parameters
Name Description
id*
array[null]
Required
Query parameters
Name Description
limit
Integer
offset
Integer
count
Boolean
sort
String

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


smbSharesecIdIdPut

Update the ACL on the share specified by the numerical index `id`. Will write changes to both /var/db/system/samba4/share_info.tdb and the configuration file.


/smb/sharesec/id/{id}

Usage and SDK Samples

curl -X PUT -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/smb/sharesec/id/{id}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.SmbSharesecApi;

import java.io.File;
import java.util.*;

public class SmbSharesecApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        SmbSharesecApi apiInstance = new SmbSharesecApi();
        Integer id = 56; // Integer | 
        Smb_sharesec_update_1 body = ; // Smb_sharesec_update_1 | 
        try {
            apiInstance.smbSharesecIdIdPut(id, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling SmbSharesecApi#smbSharesecIdIdPut");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::SmbSharesecApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::SmbSharesecApi->new();
my $id = 56; # Integer | 
my $body = WWW::SwaggerClient::Object::Smb_sharesec_update_1->new(); # Smb_sharesec_update_1 | 

eval { 
    $api_instance->smbSharesecIdIdPut(id => $id, body => $body);
};
if ($@) {
    warn "Exception when calling SmbSharesecApi->smbSharesecIdIdPut: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.SmbSharesecApi()
id = 56 # Integer | 
body =  # Smb_sharesec_update_1 |  (optional)

try: 
    api_instance.smb_sharesec_id_id_put(id, body=body)
except ApiException as e:
    print("Exception when calling SmbSharesecApi->smbSharesecIdIdPut: %s\n" % e)

Parameters

Path parameters
Name Description
id*
Integer
Required
Body parameters
Name Description
body

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


smbSharesecPost

Update the ACL on a given SMB share. Will write changes to both /var/db/system/samba4/share_info.tdb and the configuration file. Since an SMB share will _always_ have an ACL present, there is little distinction between the `create` and `update` methods apart from arguments. `share_name` - name of SMB share. `share_acl` a list of ACL entries (dictionaries) with the following keys: `ae_who_sid` who the ACL entry applies to expressed as a Windows SID `ae_who_name` who the ACL entry applies to expressed as a name. `ae_who_name` is a dictionary containing the following keys: `domain` that the user is a member of, `name` username in the domain. The domain for local users is the netbios name of the FreeNAS server. `ae_perm` string representation of the permissions granted to the user or group. `FULL` grants read, write, execute, delete, write acl, and change owner. `CHANGE` grants read, write, execute, and delete. `READ` grants read and execute. `ae_type` can be ALLOWED or DENIED.


/smb/sharesec

Usage and SDK Samples

curl -X POST -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/smb/sharesec"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.SmbSharesecApi;

import java.io.File;
import java.util.*;

public class SmbSharesecApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        SmbSharesecApi apiInstance = new SmbSharesecApi();
        Smb_sharesec_create_0 body = ; // Smb_sharesec_create_0 | 
        try {
            apiInstance.smbSharesecPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling SmbSharesecApi#smbSharesecPost");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::SmbSharesecApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::SmbSharesecApi->new();
my $body = WWW::SwaggerClient::Object::Smb_sharesec_create_0->new(); # Smb_sharesec_create_0 | 

eval { 
    $api_instance->smbSharesecPost(body => $body);
};
if ($@) {
    warn "Exception when calling SmbSharesecApi->smbSharesecPost: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.SmbSharesecApi()
body =  # Smb_sharesec_create_0 |  (optional)

try: 
    api_instance.smb_sharesec_post(body=body)
except ApiException as e:
    print("Exception when calling SmbSharesecApi->smbSharesecPost: %s\n" % e)

Parameters

Body parameters
Name Description
body

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


smbSharesecSynchronizeAclsGet

Synchronize the share ACL stored in the config database with Samba's running configuration as reflected in the share_info.tdb file. The only situation in which the configuration stored in the database will overwrite samba's running configuration is if share_info.tdb is empty. Samba fakes a single S-1-1-0:ALLOW/0x0/FULL entry in the absence of an entry for a share in share_info.tdb.


/smb/sharesec/synchronize_acls

Usage and SDK Samples

curl -X GET -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/smb/sharesec/synchronize_acls"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.SmbSharesecApi;

import java.io.File;
import java.util.*;

public class SmbSharesecApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        SmbSharesecApi apiInstance = new SmbSharesecApi();
        try {
            apiInstance.smbSharesecSynchronizeAclsGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling SmbSharesecApi#smbSharesecSynchronizeAclsGet");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::SmbSharesecApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::SmbSharesecApi->new();

eval { 
    $api_instance->smbSharesecSynchronizeAclsGet();
};
if ($@) {
    warn "Exception when calling SmbSharesecApi->smbSharesecSynchronizeAclsGet: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.SmbSharesecApi()

try: 
    api_instance.smb_sharesec_synchronize_acls_get()
except ApiException as e:
    print("Exception when calling SmbSharesecApi->smbSharesecSynchronizeAclsGet: %s\n" % e)

Parameters

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


Snmp

snmpGet


/snmp

Usage and SDK Samples

curl -X GET -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/snmp"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.SnmpApi;

import java.io.File;
import java.util.*;

public class SnmpApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        SnmpApi apiInstance = new SnmpApi();
        try {
            apiInstance.snmpGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling SnmpApi#snmpGet");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::SnmpApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::SnmpApi->new();

eval { 
    $api_instance->snmpGet();
};
if ($@) {
    warn "Exception when calling SnmpApi->snmpGet: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.SnmpApi()

try: 
    api_instance.snmp_get()
except ApiException as e:
    print("Exception when calling SnmpApi->snmpGet: %s\n" % e)

Parameters

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


snmpPut

Update SNMP Service Configuration. `v3` when set enables SNMP version 3. `v3_username`, `v3_authtype`, `v3_password`, `v3_privproto` and `v3_privpassphrase` are only used when `v3` is enabled.


/snmp

Usage and SDK Samples

curl -X PUT -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/snmp"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.SnmpApi;

import java.io.File;
import java.util.*;

public class SnmpApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        SnmpApi apiInstance = new SnmpApi();
        Snmp_update_0 body = ; // Snmp_update_0 | 
        try {
            apiInstance.snmpPut(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling SnmpApi#snmpPut");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::SnmpApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::SnmpApi->new();
my $body = WWW::SwaggerClient::Object::Snmp_update_0->new(); # Snmp_update_0 | 

eval { 
    $api_instance->snmpPut(body => $body);
};
if ($@) {
    warn "Exception when calling SnmpApi->snmpPut: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.SnmpApi()
body =  # Snmp_update_0 |  (optional)

try: 
    api_instance.snmp_put(body=body)
except ApiException as e:
    print("Exception when calling SnmpApi->snmpPut: %s\n" % e)

Parameters

Body parameters
Name Description
body

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


Ssh

sshBindifaceChoicesGet

Available choices for the bindiface attribute of SSH service.


/ssh/bindiface_choices

Usage and SDK Samples

curl -X GET -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/ssh/bindiface_choices"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.SshApi;

import java.io.File;
import java.util.*;

public class SshApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        SshApi apiInstance = new SshApi();
        try {
            apiInstance.sshBindifaceChoicesGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling SshApi#sshBindifaceChoicesGet");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::SshApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::SshApi->new();

eval { 
    $api_instance->sshBindifaceChoicesGet();
};
if ($@) {
    warn "Exception when calling SshApi->sshBindifaceChoicesGet: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.SshApi()

try: 
    api_instance.ssh_bindiface_choices_get()
except ApiException as e:
    print("Exception when calling SshApi->sshBindifaceChoicesGet: %s\n" % e)

Parameters

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


sshGet


/ssh

Usage and SDK Samples

curl -X GET -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/ssh"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.SshApi;

import java.io.File;
import java.util.*;

public class SshApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        SshApi apiInstance = new SshApi();
        try {
            apiInstance.sshGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling SshApi#sshGet");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::SshApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::SshApi->new();

eval { 
    $api_instance->sshGet();
};
if ($@) {
    warn "Exception when calling SshApi->sshGet: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.SshApi()

try: 
    api_instance.ssh_get()
except ApiException as e:
    print("Exception when calling SshApi->sshGet: %s\n" % e)

Parameters

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


sshPut

Update settings of SSH daemon service. If `bindiface` is empty it will listen for all available addresses.


/ssh

Usage and SDK Samples

curl -X PUT -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/ssh"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.SshApi;

import java.io.File;
import java.util.*;

public class SshApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        SshApi apiInstance = new SshApi();
        Ssh_update_0 body = ; // Ssh_update_0 | 
        try {
            apiInstance.sshPut(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling SshApi#sshPut");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::SshApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::SshApi->new();
my $body = WWW::SwaggerClient::Object::Ssh_update_0->new(); # Ssh_update_0 | 

eval { 
    $api_instance->sshPut(body => $body);
};
if ($@) {
    warn "Exception when calling SshApi->sshPut: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.SshApi()
body =  # Ssh_update_0 |  (optional)

try: 
    api_instance.ssh_put(body=body)
except ApiException as e:
    print("Exception when calling SshApi->sshPut: %s\n" % e)

Parameters

Body parameters
Name Description
body

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


Staticroute

staticrouteGet


/staticroute

Usage and SDK Samples

curl -X GET -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/staticroute?limit=&offset=&count=&sort="
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.StaticrouteApi;

import java.io.File;
import java.util.*;

public class StaticrouteApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        StaticrouteApi apiInstance = new StaticrouteApi();
        Integer limit = 56; // Integer | 
        Integer offset = 56; // Integer | 
        Boolean count = true; // Boolean | 
        String sort = sort_example; // String | 
        try {
            apiInstance.staticrouteGet(limit, offset, count, sort);
        } catch (ApiException e) {
            System.err.println("Exception when calling StaticrouteApi#staticrouteGet");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::StaticrouteApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::StaticrouteApi->new();
my $limit = 56; # Integer | 
my $offset = 56; # Integer | 
my $count = true; # Boolean | 
my $sort = sort_example; # String | 

eval { 
    $api_instance->staticrouteGet(limit => $limit, offset => $offset, count => $count, sort => $sort);
};
if ($@) {
    warn "Exception when calling StaticrouteApi->staticrouteGet: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.StaticrouteApi()
limit = 56 # Integer |  (optional)
offset = 56 # Integer |  (optional)
count = true # Boolean |  (optional)
sort = sort_example # String |  (optional)

try: 
    api_instance.staticroute_get(limit=limit, offset=offset, count=count, sort=sort)
except ApiException as e:
    print("Exception when calling StaticrouteApi->staticrouteGet: %s\n" % e)

Parameters

Query parameters
Name Description
limit
Integer
offset
Integer
count
Boolean
sort
String

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


staticrouteIdIdDelete

Delete Static Route of `id`.


/staticroute/id/{id}

Usage and SDK Samples

curl -X DELETE -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/staticroute/id/{id}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.StaticrouteApi;

import java.io.File;
import java.util.*;

public class StaticrouteApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        StaticrouteApi apiInstance = new StaticrouteApi();
        Integer id = 56; // Integer | 
        try {
            apiInstance.staticrouteIdIdDelete(id);
        } catch (ApiException e) {
            System.err.println("Exception when calling StaticrouteApi#staticrouteIdIdDelete");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::StaticrouteApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::StaticrouteApi->new();
my $id = 56; # Integer | 

eval { 
    $api_instance->staticrouteIdIdDelete(id => $id);
};
if ($@) {
    warn "Exception when calling StaticrouteApi->staticrouteIdIdDelete: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.StaticrouteApi()
id = 56 # Integer | 

try: 
    api_instance.staticroute_id_id_delete(id)
except ApiException as e:
    print("Exception when calling StaticrouteApi->staticrouteIdIdDelete: %s\n" % e)

Parameters

Path parameters
Name Description
id*
Integer
Required

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


staticrouteIdIdGet


/staticroute/id/{id}

Usage and SDK Samples

curl -X GET -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/staticroute/id/{id}?limit=&offset=&count=&sort="
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.StaticrouteApi;

import java.io.File;
import java.util.*;

public class StaticrouteApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        StaticrouteApi apiInstance = new StaticrouteApi();
        array[null] id = ; // array[null] | 
        Integer limit = 56; // Integer | 
        Integer offset = 56; // Integer | 
        Boolean count = true; // Boolean | 
        String sort = sort_example; // String | 
        try {
            apiInstance.staticrouteIdIdGet(id, limit, offset, count, sort);
        } catch (ApiException e) {
            System.err.println("Exception when calling StaticrouteApi#staticrouteIdIdGet");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::StaticrouteApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::StaticrouteApi->new();
my $id = []; # array[null] | 
my $limit = 56; # Integer | 
my $offset = 56; # Integer | 
my $count = true; # Boolean | 
my $sort = sort_example; # String | 

eval { 
    $api_instance->staticrouteIdIdGet(id => $id, limit => $limit, offset => $offset, count => $count, sort => $sort);
};
if ($@) {
    warn "Exception when calling StaticrouteApi->staticrouteIdIdGet: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.StaticrouteApi()
id =  # array[null] | 
limit = 56 # Integer |  (optional)
offset = 56 # Integer |  (optional)
count = true # Boolean |  (optional)
sort = sort_example # String |  (optional)

try: 
    api_instance.staticroute_id_id_get(id, limit=limit, offset=offset, count=count, sort=sort)
except ApiException as e:
    print("Exception when calling StaticrouteApi->staticrouteIdIdGet: %s\n" % e)

Parameters

Path parameters
Name Description
id*
array[null]
Required
Query parameters
Name Description
limit
Integer
offset
Integer
count
Boolean
sort
String

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


staticrouteIdIdPut

Update Static Route of `id`.


/staticroute/id/{id}

Usage and SDK Samples

curl -X PUT -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/staticroute/id/{id}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.StaticrouteApi;

import java.io.File;
import java.util.*;

public class StaticrouteApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        StaticrouteApi apiInstance = new StaticrouteApi();
        Integer id = 56; // Integer | 
        Staticroute_update_1 body = ; // Staticroute_update_1 | 
        try {
            apiInstance.staticrouteIdIdPut(id, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling StaticrouteApi#staticrouteIdIdPut");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::StaticrouteApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::StaticrouteApi->new();
my $id = 56; # Integer | 
my $body = WWW::SwaggerClient::Object::Staticroute_update_1->new(); # Staticroute_update_1 | 

eval { 
    $api_instance->staticrouteIdIdPut(id => $id, body => $body);
};
if ($@) {
    warn "Exception when calling StaticrouteApi->staticrouteIdIdPut: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.StaticrouteApi()
id = 56 # Integer | 
body =  # Staticroute_update_1 |  (optional)

try: 
    api_instance.staticroute_id_id_put(id, body=body)
except ApiException as e:
    print("Exception when calling StaticrouteApi->staticrouteIdIdPut: %s\n" % e)

Parameters

Path parameters
Name Description
id*
Integer
Required
Body parameters
Name Description
body

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


staticroutePost

Create a Static Route. Address families of `gateway` and `destination` should match when creating a static route. `description` is an optional attribute for any notes regarding the static route.


/staticroute

Usage and SDK Samples

curl -X POST -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/staticroute"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.StaticrouteApi;

import java.io.File;
import java.util.*;

public class StaticrouteApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        StaticrouteApi apiInstance = new StaticrouteApi();
        Staticroute_create_0 body = ; // Staticroute_create_0 | 
        try {
            apiInstance.staticroutePost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling StaticrouteApi#staticroutePost");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::StaticrouteApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::StaticrouteApi->new();
my $body = WWW::SwaggerClient::Object::Staticroute_create_0->new(); # Staticroute_create_0 | 

eval { 
    $api_instance->staticroutePost(body => $body);
};
if ($@) {
    warn "Exception when calling StaticrouteApi->staticroutePost: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.StaticrouteApi()
body =  # Staticroute_create_0 |  (optional)

try: 
    api_instance.staticroute_post(body=body)
except ApiException as e:
    print("Exception when calling StaticrouteApi->staticroutePost: %s\n" % e)

Parameters

Body parameters
Name Description
body

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


Stats

statsGetDataPost

Get data points from rrd files.


/stats/get_data

Usage and SDK Samples

curl -X POST -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/stats/get_data"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.StatsApi;

import java.io.File;
import java.util.*;

public class StatsApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        StatsApi apiInstance = new StatsApi();
        Stats_get_data body = ; // Stats_get_data | 
        try {
            apiInstance.statsGetDataPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling StatsApi#statsGetDataPost");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::StatsApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::StatsApi->new();
my $body = WWW::SwaggerClient::Object::Stats_get_data->new(); # Stats_get_data | 

eval { 
    $api_instance->statsGetDataPost(body => $body);
};
if ($@) {
    warn "Exception when calling StatsApi->statsGetDataPost: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.StatsApi()
body =  # Stats_get_data |  (optional)

try: 
    api_instance.stats_get_data_post(body=body)
except ApiException as e:
    print("Exception when calling StatsApi->statsGetDataPost: %s\n" % e)

Parameters

Body parameters
Name Description
body

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


statsGetDatasetInfoPost

Returns info about a given dataset from some source.


/stats/get_dataset_info

Usage and SDK Samples

curl -X POST -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/stats/get_dataset_info"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.StatsApi;

import java.io.File;
import java.util.*;

public class StatsApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        StatsApi apiInstance = new StatsApi();
        Stats_get_dataset_info body = ; // Stats_get_dataset_info | 
        try {
            apiInstance.statsGetDatasetInfoPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling StatsApi#statsGetDatasetInfoPost");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::StatsApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::StatsApi->new();
my $body = WWW::SwaggerClient::Object::Stats_get_dataset_info->new(); # Stats_get_dataset_info | 

eval { 
    $api_instance->statsGetDatasetInfoPost(body => $body);
};
if ($@) {
    warn "Exception when calling StatsApi->statsGetDatasetInfoPost: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.StatsApi()
body =  # Stats_get_dataset_info |  (optional)

try: 
    api_instance.stats_get_dataset_info_post(body=body)
except ApiException as e:
    print("Exception when calling StatsApi->statsGetDatasetInfoPost: %s\n" % e)

Parameters

Body parameters
Name Description
body

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


statsGetSourcesGet

Returns an object with all available sources tried with metric datasets.


/stats/get_sources

Usage and SDK Samples

curl -X GET -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/stats/get_sources"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.StatsApi;

import java.io.File;
import java.util.*;

public class StatsApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        StatsApi apiInstance = new StatsApi();
        try {
            apiInstance.statsGetSourcesGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling StatsApi#statsGetSourcesGet");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::StatsApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::StatsApi->new();

eval { 
    $api_instance->statsGetSourcesGet();
};
if ($@) {
    warn "Exception when calling StatsApi->statsGetSourcesGet: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.StatsApi()

try: 
    api_instance.stats_get_sources_get()
except ApiException as e:
    print("Exception when calling StatsApi->statsGetSourcesGet: %s\n" % e)

Parameters

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


Support

supportFetchCategoriesPost

Fetch all the categories available for `username` using `password`. Returns a dict with the category name as a key and id as value.


/support/fetch_categories

Usage and SDK Samples

curl -X POST -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/support/fetch_categories"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.SupportApi;

import java.io.File;
import java.util.*;

public class SupportApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        SupportApi apiInstance = new SupportApi();
        Support_fetch_categories body = ; // Support_fetch_categories | 
        try {
            apiInstance.supportFetchCategoriesPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling SupportApi#supportFetchCategoriesPost");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::SupportApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::SupportApi->new();
my $body = WWW::SwaggerClient::Object::Support_fetch_categories->new(); # Support_fetch_categories | 

eval { 
    $api_instance->supportFetchCategoriesPost(body => $body);
};
if ($@) {
    warn "Exception when calling SupportApi->supportFetchCategoriesPost: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.SupportApi()
body =  # Support_fetch_categories |  (optional)

try: 
    api_instance.support_fetch_categories_post(body=body)
except ApiException as e:
    print("Exception when calling SupportApi->supportFetchCategoriesPost: %s\n" % e)

Parameters

Body parameters
Name Description
body

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


supportFieldsGet

Returns list of pairs of field names and field titles for Proactive Support.


/support/fields

Usage and SDK Samples

curl -X GET -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/support/fields"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.SupportApi;

import java.io.File;
import java.util.*;

public class SupportApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        SupportApi apiInstance = new SupportApi();
        try {
            apiInstance.supportFieldsGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling SupportApi#supportFieldsGet");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::SupportApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::SupportApi->new();

eval { 
    $api_instance->supportFieldsGet();
};
if ($@) {
    warn "Exception when calling SupportApi->supportFieldsGet: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.SupportApi()

try: 
    api_instance.support_fields_get()
except ApiException as e:
    print("Exception when calling SupportApi->supportFieldsGet: %s\n" % e)

Parameters

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


supportGet


/support

Usage and SDK Samples

curl -X GET -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/support"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.SupportApi;

import java.io.File;
import java.util.*;

public class SupportApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        SupportApi apiInstance = new SupportApi();
        try {
            apiInstance.supportGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling SupportApi#supportGet");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::SupportApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::SupportApi->new();

eval { 
    $api_instance->supportGet();
};
if ($@) {
    warn "Exception when calling SupportApi->supportGet: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.SupportApi()

try: 
    api_instance.support_get()
except ApiException as e:
    print("Exception when calling SupportApi->supportGet: %s\n" % e)

Parameters

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


supportIsAvailableAndEnabledGet

Returns whether Proactive Support is available and enabled.


/support/is_available_and_enabled

Usage and SDK Samples

curl -X GET -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/support/is_available_and_enabled"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.SupportApi;

import java.io.File;
import java.util.*;

public class SupportApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        SupportApi apiInstance = new SupportApi();
        try {
            apiInstance.supportIsAvailableAndEnabledGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling SupportApi#supportIsAvailableAndEnabledGet");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::SupportApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::SupportApi->new();

eval { 
    $api_instance->supportIsAvailableAndEnabledGet();
};
if ($@) {
    warn "Exception when calling SupportApi->supportIsAvailableAndEnabledGet: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.SupportApi()

try: 
    api_instance.support_is_available_and_enabled_get()
except ApiException as e:
    print("Exception when calling SupportApi->supportIsAvailableAndEnabledGet: %s\n" % e)

Parameters

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


supportIsAvailableGet

Returns whether Proactive Support is available for this product type and current license.


/support/is_available

Usage and SDK Samples

curl -X GET -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/support/is_available"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.SupportApi;

import java.io.File;
import java.util.*;

public class SupportApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        SupportApi apiInstance = new SupportApi();
        try {
            apiInstance.supportIsAvailableGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling SupportApi#supportIsAvailableGet");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::SupportApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::SupportApi->new();

eval { 
    $api_instance->supportIsAvailableGet();
};
if ($@) {
    warn "Exception when calling SupportApi->supportIsAvailableGet: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.SupportApi()

try: 
    api_instance.support_is_available_get()
except ApiException as e:
    print("Exception when calling SupportApi->supportIsAvailableGet: %s\n" % e)

Parameters

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


supportNewTicketPost

Creates a new ticket for support. This is done using the support proxy API. For FreeNAS it will be created on Redmine and for TrueNAS on SupportSuite. For FreeNAS `criticality`, `environment`, `phone`, `name` and `email` attributes are not required. For TrueNAS `username`, `password` and `type` attributes are not required.


/support/new_ticket

Usage and SDK Samples

curl -X POST -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/support/new_ticket"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.SupportApi;

import java.io.File;
import java.util.*;

public class SupportApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        SupportApi apiInstance = new SupportApi();
        Support_new_ticket_0 body = ; // Support_new_ticket_0 | 
        try {
            apiInstance.supportNewTicketPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling SupportApi#supportNewTicketPost");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::SupportApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::SupportApi->new();
my $body = WWW::SwaggerClient::Object::Support_new_ticket_0->new(); # Support_new_ticket_0 | 

eval { 
    $api_instance->supportNewTicketPost(body => $body);
};
if ($@) {
    warn "Exception when calling SupportApi->supportNewTicketPost: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.SupportApi()
body =  # Support_new_ticket_0 |  (optional)

try: 
    api_instance.support_new_ticket_post(body=body)
except ApiException as e:
    print("Exception when calling SupportApi->supportNewTicketPost: %s\n" % e)

Parameters

Body parameters
Name Description
body

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


supportPut

Update Proactive Support settings.


/support

Usage and SDK Samples

curl -X PUT -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/support"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.SupportApi;

import java.io.File;
import java.util.*;

public class SupportApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        SupportApi apiInstance = new SupportApi();
        Support_update_0 body = ; // Support_update_0 | 
        try {
            apiInstance.supportPut(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling SupportApi#supportPut");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::SupportApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::SupportApi->new();
my $body = WWW::SwaggerClient::Object::Support_update_0->new(); # Support_update_0 | 

eval { 
    $api_instance->supportPut(body => $body);
};
if ($@) {
    warn "Exception when calling SupportApi->supportPut: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.SupportApi()
body =  # Support_update_0 |  (optional)

try: 
    api_instance.support_put(body=body)
except ApiException as e:
    print("Exception when calling SupportApi->supportPut: %s\n" % e)

Parameters

Body parameters
Name Description
body

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


System

systemBootIdGet

Returns an unique boot identifier. It is supposed to be unique every system boot.


/system/boot_id

Usage and SDK Samples

curl -X GET -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/system/boot_id"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.SystemApi;

import java.io.File;
import java.util.*;

public class SystemApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        SystemApi apiInstance = new SystemApi();
        try {
            apiInstance.systemBootIdGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling SystemApi#systemBootIdGet");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::SystemApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::SystemApi->new();

eval { 
    $api_instance->systemBootIdGet();
};
if ($@) {
    warn "Exception when calling SystemApi->systemBootIdGet: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.SystemApi()

try: 
    api_instance.system_boot_id_get()
except ApiException as e:
    print("Exception when calling SystemApi->systemBootIdGet: %s\n" % e)

Parameters

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


systemEnvironmentGet

Return environment in which product is running. Possible values: - DEFAULT - EC2


/system/environment

Usage and SDK Samples

curl -X GET -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/system/environment"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.SystemApi;

import java.io.File;
import java.util.*;

public class SystemApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        SystemApi apiInstance = new SystemApi();
        try {
            apiInstance.systemEnvironmentGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling SystemApi#systemEnvironmentGet");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::SystemApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::SystemApi->new();

eval { 
    $api_instance->systemEnvironmentGet();
};
if ($@) {
    warn "Exception when calling SystemApi->systemEnvironmentGet: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.SystemApi()

try: 
    api_instance.system_environment_get()
except ApiException as e:
    print("Exception when calling SystemApi->systemEnvironmentGet: %s\n" % e)

Parameters

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


systemFeatureEnabledPost

Returns whether the `feature` is enabled or not


/system/feature_enabled

Usage and SDK Samples

curl -X POST -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/system/feature_enabled"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.SystemApi;

import java.io.File;
import java.util.*;

public class SystemApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        SystemApi apiInstance = new SystemApi();
        String body = ; // String | 
        try {
            apiInstance.systemFeatureEnabledPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling SystemApi#systemFeatureEnabledPost");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::SystemApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::SystemApi->new();
my $body = WWW::SwaggerClient::Object::String->new(); # String | 

eval { 
    $api_instance->systemFeatureEnabledPost(body => $body);
};
if ($@) {
    warn "Exception when calling SystemApi->systemFeatureEnabledPost: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.SystemApi()
body =  # String |  (optional)

try: 
    api_instance.system_feature_enabled_post(body=body)
except ApiException as e:
    print("Exception when calling SystemApi->systemFeatureEnabledPost: %s\n" % e)

Parameters

Body parameters
Name Description
body

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


systemInfoGet

Returns basic system information.


/system/info

Usage and SDK Samples

curl -X GET -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/system/info"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.SystemApi;

import java.io.File;
import java.util.*;

public class SystemApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        SystemApi apiInstance = new SystemApi();
        try {
            apiInstance.systemInfoGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling SystemApi#systemInfoGet");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::SystemApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::SystemApi->new();

eval { 
    $api_instance->systemInfoGet();
};
if ($@) {
    warn "Exception when calling SystemApi->systemInfoGet: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.SystemApi()

try: 
    api_instance.system_info_get()
except ApiException as e:
    print("Exception when calling SystemApi->systemInfoGet: %s\n" % e)

Parameters

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


systemIsFreenasGet

FreeNAS is now TrueNAS CORE. DEPRECATED: Use `system.product_type`


/system/is_freenas

Usage and SDK Samples

curl -X GET -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/system/is_freenas"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.SystemApi;

import java.io.File;
import java.util.*;

public class SystemApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        SystemApi apiInstance = new SystemApi();
        try {
            apiInstance.systemIsFreenasGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling SystemApi#systemIsFreenasGet");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::SystemApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::SystemApi->new();

eval { 
    $api_instance->systemIsFreenasGet();
};
if ($@) {
    warn "Exception when calling SystemApi->systemIsFreenasGet: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.SystemApi()

try: 
    api_instance.system_is_freenas_get()
except ApiException as e:
    print("Exception when calling SystemApi->systemIsFreenasGet: %s\n" % e)

Parameters

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


systemLicenseUpdatePost

Update license file.


/system/license_update

Usage and SDK Samples

curl -X POST -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/system/license_update"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.SystemApi;

import java.io.File;
import java.util.*;

public class SystemApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        SystemApi apiInstance = new SystemApi();
        String body = ; // String | 
        try {
            apiInstance.systemLicenseUpdatePost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling SystemApi#systemLicenseUpdatePost");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::SystemApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::SystemApi->new();
my $body = WWW::SwaggerClient::Object::String->new(); # String | 

eval { 
    $api_instance->systemLicenseUpdatePost(body => $body);
};
if ($@) {
    warn "Exception when calling SystemApi->systemLicenseUpdatePost: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.SystemApi()
body =  # String |  (optional)

try: 
    api_instance.system_license_update_post(body=body)
except ApiException as e:
    print("Exception when calling SystemApi->systemLicenseUpdatePost: %s\n" % e)

Parameters

Body parameters
Name Description
body

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


systemProductNameGet

Returns name of the product we are using.


/system/product_name

Usage and SDK Samples

curl -X GET -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/system/product_name"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.SystemApi;

import java.io.File;
import java.util.*;

public class SystemApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        SystemApi apiInstance = new SystemApi();
        try {
            apiInstance.systemProductNameGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling SystemApi#systemProductNameGet");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::SystemApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::SystemApi->new();

eval { 
    $api_instance->systemProductNameGet();
};
if ($@) {
    warn "Exception when calling SystemApi->systemProductNameGet: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.SystemApi()

try: 
    api_instance.system_product_name_get()
except ApiException as e:
    print("Exception when calling SystemApi->systemProductNameGet: %s\n" % e)

Parameters

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


systemProductTypeGet

Returns the type of the product. CORE - TrueNAS Core, community version ENTERPRISE - TrueNAS Enterprise, appliance version SCALE - TrueNAS SCALE


/system/product_type

Usage and SDK Samples

curl -X GET -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/system/product_type"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.SystemApi;

import java.io.File;
import java.util.*;

public class SystemApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        SystemApi apiInstance = new SystemApi();
        try {
            apiInstance.systemProductTypeGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling SystemApi#systemProductTypeGet");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::SystemApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::SystemApi->new();

eval { 
    $api_instance->systemProductTypeGet();
};
if ($@) {
    warn "Exception when calling SystemApi->systemProductTypeGet: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.SystemApi()

try: 
    api_instance.system_product_type_get()
except ApiException as e:
    print("Exception when calling SystemApi->systemProductTypeGet: %s\n" % e)

Parameters

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


systemReadyGet

Returns whether the system completed boot and is ready to use


/system/ready

Usage and SDK Samples

curl -X GET -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/system/ready"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.SystemApi;

import java.io.File;
import java.util.*;

public class SystemApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        SystemApi apiInstance = new SystemApi();
        try {
            apiInstance.systemReadyGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling SystemApi#systemReadyGet");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::SystemApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::SystemApi->new();

eval { 
    $api_instance->systemReadyGet();
};
if ($@) {
    warn "Exception when calling SystemApi->systemReadyGet: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.SystemApi()

try: 
    api_instance.system_ready_get()
except ApiException as e:
    print("Exception when calling SystemApi->systemReadyGet: %s\n" % e)

Parameters

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


systemRebootPost

Reboots the operating system. Emits an "added" event of name "system" and id "reboot".


/system/reboot

Usage and SDK Samples

curl -X POST -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/system/reboot"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.SystemApi;

import java.io.File;
import java.util.*;

public class SystemApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        SystemApi apiInstance = new SystemApi();
        System_reboot_0 body = ; // System_reboot_0 | 
        try {
            apiInstance.systemRebootPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling SystemApi#systemRebootPost");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::SystemApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::SystemApi->new();
my $body = WWW::SwaggerClient::Object::System_reboot_0->new(); # System_reboot_0 | 

eval { 
    $api_instance->systemRebootPost(body => $body);
};
if ($@) {
    warn "Exception when calling SystemApi->systemRebootPost: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.SystemApi()
body =  # System_reboot_0 |  (optional)

try: 
    api_instance.system_reboot_post(body=body)
except ApiException as e:
    print("Exception when calling SystemApi->systemRebootPost: %s\n" % e)

Parameters

Body parameters
Name Description
body

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


systemShutdownPost

Shuts down the operating system. An "added" event of name "system" and id "shutdown" is emitted when shutdown is initiated.


/system/shutdown

Usage and SDK Samples

curl -X POST -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/system/shutdown"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.SystemApi;

import java.io.File;
import java.util.*;

public class SystemApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        SystemApi apiInstance = new SystemApi();
        System_shutdown_0 body = ; // System_shutdown_0 | 
        try {
            apiInstance.systemShutdownPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling SystemApi#systemShutdownPost");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::SystemApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::SystemApi->new();
my $body = WWW::SwaggerClient::Object::System_shutdown_0->new(); # System_shutdown_0 | 

eval { 
    $api_instance->systemShutdownPost(body => $body);
};
if ($@) {
    warn "Exception when calling SystemApi->systemShutdownPost: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.SystemApi()
body =  # System_shutdown_0 |  (optional)

try: 
    api_instance.system_shutdown_post(body=body)
except ApiException as e:
    print("Exception when calling SystemApi->systemShutdownPost: %s\n" % e)

Parameters

Body parameters
Name Description
body

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


systemStateGet

Returns system state: "BOOTING" - System is booting "READY" - System completed boot and is ready to use "SHUTTING_DOWN" - System is shutting down


/system/state

Usage and SDK Samples

curl -X GET -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/system/state"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.SystemApi;

import java.io.File;
import java.util.*;

public class SystemApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        SystemApi apiInstance = new SystemApi();
        try {
            apiInstance.systemStateGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling SystemApi#systemStateGet");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::SystemApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::SystemApi->new();

eval { 
    $api_instance->systemStateGet();
};
if ($@) {
    warn "Exception when calling SystemApi->systemStateGet: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.SystemApi()

try: 
    api_instance.system_state_get()
except ApiException as e:
    print("Exception when calling SystemApi->systemStateGet: %s\n" % e)

Parameters

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


systemVersionGet

Returns software version of the system.


/system/version

Usage and SDK Samples

curl -X GET -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/system/version"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.SystemApi;

import java.io.File;
import java.util.*;

public class SystemApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        SystemApi apiInstance = new SystemApi();
        try {
            apiInstance.systemVersionGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling SystemApi#systemVersionGet");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::SystemApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::SystemApi->new();

eval { 
    $api_instance->systemVersionGet();
};
if ($@) {
    warn "Exception when calling SystemApi->systemVersionGet: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.SystemApi()

try: 
    api_instance.system_version_get()
except ApiException as e:
    print("Exception when calling SystemApi->systemVersionGet: %s\n" % e)

Parameters

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


SystemAdvanced

systemAdvancedGet


/system/advanced

Usage and SDK Samples

curl -X GET -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/system/advanced"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.SystemAdvancedApi;

import java.io.File;
import java.util.*;

public class SystemAdvancedApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        SystemAdvancedApi apiInstance = new SystemAdvancedApi();
        try {
            apiInstance.systemAdvancedGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling SystemAdvancedApi#systemAdvancedGet");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::SystemAdvancedApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::SystemAdvancedApi->new();

eval { 
    $api_instance->systemAdvancedGet();
};
if ($@) {
    warn "Exception when calling SystemAdvancedApi->systemAdvancedGet: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.SystemAdvancedApi()

try: 
    api_instance.system_advanced_get()
except ApiException as e:
    print("Exception when calling SystemAdvancedApi->systemAdvancedGet: %s\n" % e)

Parameters

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


systemAdvancedPut

Update System Advanced Service Configuration. `consolemenu` should be disabled if the menu at console is not desired. It will default to standard login in the console if disabled. `autotune` when enabled executes autotune script which attempts to optimize the system based on the installed hardware. When `syslogserver` is defined, logs of `sysloglevel` or above are sent.


/system/advanced

Usage and SDK Samples

curl -X PUT -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/system/advanced"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.SystemAdvancedApi;

import java.io.File;
import java.util.*;

public class SystemAdvancedApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        SystemAdvancedApi apiInstance = new SystemAdvancedApi();
        System_advanced_update_0 body = ; // System_advanced_update_0 | 
        try {
            apiInstance.systemAdvancedPut(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling SystemAdvancedApi#systemAdvancedPut");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::SystemAdvancedApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::SystemAdvancedApi->new();
my $body = WWW::SwaggerClient::Object::System_advanced_update_0->new(); # System_advanced_update_0 | 

eval { 
    $api_instance->systemAdvancedPut(body => $body);
};
if ($@) {
    warn "Exception when calling SystemAdvancedApi->systemAdvancedPut: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.SystemAdvancedApi()
body =  # System_advanced_update_0 |  (optional)

try: 
    api_instance.system_advanced_put(body=body)
except ApiException as e:
    print("Exception when calling SystemAdvancedApi->systemAdvancedPut: %s\n" % e)

Parameters

Body parameters
Name Description
body

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


systemAdvancedSedGlobalPasswordGet

Returns configured global SED password.


/system/advanced/sed_global_password

Usage and SDK Samples

curl -X GET -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/system/advanced/sed_global_password"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.SystemAdvancedApi;

import java.io.File;
import java.util.*;

public class SystemAdvancedApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        SystemAdvancedApi apiInstance = new SystemAdvancedApi();
        try {
            apiInstance.systemAdvancedSedGlobalPasswordGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling SystemAdvancedApi#systemAdvancedSedGlobalPasswordGet");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::SystemAdvancedApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::SystemAdvancedApi->new();

eval { 
    $api_instance->systemAdvancedSedGlobalPasswordGet();
};
if ($@) {
    warn "Exception when calling SystemAdvancedApi->systemAdvancedSedGlobalPasswordGet: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.SystemAdvancedApi()

try: 
    api_instance.system_advanced_sed_global_password_get()
except ApiException as e:
    print("Exception when calling SystemAdvancedApi->systemAdvancedSedGlobalPasswordGet: %s\n" % e)

Parameters

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


systemAdvancedSerialPortChoicesGet

Get available choices for `serialport`.


/system/advanced/serial_port_choices

Usage and SDK Samples

curl -X GET -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/system/advanced/serial_port_choices"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.SystemAdvancedApi;

import java.io.File;
import java.util.*;

public class SystemAdvancedApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        SystemAdvancedApi apiInstance = new SystemAdvancedApi();
        try {
            apiInstance.systemAdvancedSerialPortChoicesGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling SystemAdvancedApi#systemAdvancedSerialPortChoicesGet");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::SystemAdvancedApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::SystemAdvancedApi->new();

eval { 
    $api_instance->systemAdvancedSerialPortChoicesGet();
};
if ($@) {
    warn "Exception when calling SystemAdvancedApi->systemAdvancedSerialPortChoicesGet: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.SystemAdvancedApi()

try: 
    api_instance.system_advanced_serial_port_choices_get()
except ApiException as e:
    print("Exception when calling SystemAdvancedApi->systemAdvancedSerialPortChoicesGet: %s\n" % e)

Parameters

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


SystemGeneral

systemGeneralCountryChoicesGet

Returns country choices.


/system/general/country_choices

Usage and SDK Samples

curl -X GET -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/system/general/country_choices"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.SystemGeneralApi;

import java.io.File;
import java.util.*;

public class SystemGeneralApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        SystemGeneralApi apiInstance = new SystemGeneralApi();
        try {
            apiInstance.systemGeneralCountryChoicesGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling SystemGeneralApi#systemGeneralCountryChoicesGet");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::SystemGeneralApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::SystemGeneralApi->new();

eval { 
    $api_instance->systemGeneralCountryChoicesGet();
};
if ($@) {
    warn "Exception when calling SystemGeneralApi->systemGeneralCountryChoicesGet: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.SystemGeneralApi()

try: 
    api_instance.system_general_country_choices_get()
except ApiException as e:
    print("Exception when calling SystemGeneralApi->systemGeneralCountryChoicesGet: %s\n" % e)

Parameters

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


systemGeneralGet


/system/general

Usage and SDK Samples

curl -X GET -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/system/general"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.SystemGeneralApi;

import java.io.File;
import java.util.*;

public class SystemGeneralApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        SystemGeneralApi apiInstance = new SystemGeneralApi();
        try {
            apiInstance.systemGeneralGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling SystemGeneralApi#systemGeneralGet");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::SystemGeneralApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::SystemGeneralApi->new();

eval { 
    $api_instance->systemGeneralGet();
};
if ($@) {
    warn "Exception when calling SystemGeneralApi->systemGeneralGet: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.SystemGeneralApi()

try: 
    api_instance.system_general_get()
except ApiException as e:
    print("Exception when calling SystemGeneralApi->systemGeneralGet: %s\n" % e)

Parameters

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


systemGeneralKbdmapChoicesGet

Returns kbdmap choices.


/system/general/kbdmap_choices

Usage and SDK Samples

curl -X GET -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/system/general/kbdmap_choices"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.SystemGeneralApi;

import java.io.File;
import java.util.*;

public class SystemGeneralApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        SystemGeneralApi apiInstance = new SystemGeneralApi();
        try {
            apiInstance.systemGeneralKbdmapChoicesGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling SystemGeneralApi#systemGeneralKbdmapChoicesGet");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::SystemGeneralApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::SystemGeneralApi->new();

eval { 
    $api_instance->systemGeneralKbdmapChoicesGet();
};
if ($@) {
    warn "Exception when calling SystemGeneralApi->systemGeneralKbdmapChoicesGet: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.SystemGeneralApi()

try: 
    api_instance.system_general_kbdmap_choices_get()
except ApiException as e:
    print("Exception when calling SystemGeneralApi->systemGeneralKbdmapChoicesGet: %s\n" % e)

Parameters

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


systemGeneralLanguageChoicesGet

Returns language choices.


/system/general/language_choices

Usage and SDK Samples

curl -X GET -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/system/general/language_choices"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.SystemGeneralApi;

import java.io.File;
import java.util.*;

public class SystemGeneralApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        SystemGeneralApi apiInstance = new SystemGeneralApi();
        try {
            apiInstance.systemGeneralLanguageChoicesGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling SystemGeneralApi#systemGeneralLanguageChoicesGet");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::SystemGeneralApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::SystemGeneralApi->new();

eval { 
    $api_instance->systemGeneralLanguageChoicesGet();
};
if ($@) {
    warn "Exception when calling SystemGeneralApi->systemGeneralLanguageChoicesGet: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.SystemGeneralApi()

try: 
    api_instance.system_general_language_choices_get()
except ApiException as e:
    print("Exception when calling SystemGeneralApi->systemGeneralLanguageChoicesGet: %s\n" % e)

Parameters

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


systemGeneralLocalUrlGet

Returns configured local url in the format of protocol://host:port


/system/general/local_url

Usage and SDK Samples

curl -X GET -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/system/general/local_url"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.SystemGeneralApi;

import java.io.File;
import java.util.*;

public class SystemGeneralApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        SystemGeneralApi apiInstance = new SystemGeneralApi();
        try {
            apiInstance.systemGeneralLocalUrlGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling SystemGeneralApi#systemGeneralLocalUrlGet");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::SystemGeneralApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::SystemGeneralApi->new();

eval { 
    $api_instance->systemGeneralLocalUrlGet();
};
if ($@) {
    warn "Exception when calling SystemGeneralApi->systemGeneralLocalUrlGet: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.SystemGeneralApi()

try: 
    api_instance.system_general_local_url_get()
except ApiException as e:
    print("Exception when calling SystemGeneralApi->systemGeneralLocalUrlGet: %s\n" % e)

Parameters

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


systemGeneralPut

Update System General Service Configuration. `ui_certificate` is used to enable HTTPS access to the system. If `ui_certificate` is not configured on boot, it is automatically created by the system. `ui_httpsredirect` when set, makes sure that all HTTP requests are converted to HTTPS requests to better enhance security. `ui_address` and `ui_v6address` are a list of valid ipv4/ipv6 addresses respectively which the system will listen on. `syslogserver` and `sysloglevel` are deprecated fields as of 11.3 and will be permanently moved to system.advanced.update for 12.0


/system/general

Usage and SDK Samples

curl -X PUT -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/system/general"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.SystemGeneralApi;

import java.io.File;
import java.util.*;

public class SystemGeneralApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        SystemGeneralApi apiInstance = new SystemGeneralApi();
        System_general_update_0 body = ; // System_general_update_0 | 
        try {
            apiInstance.systemGeneralPut(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling SystemGeneralApi#systemGeneralPut");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::SystemGeneralApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::SystemGeneralApi->new();
my $body = WWW::SwaggerClient::Object::System_general_update_0->new(); # System_general_update_0 | 

eval { 
    $api_instance->systemGeneralPut(body => $body);
};
if ($@) {
    warn "Exception when calling SystemGeneralApi->systemGeneralPut: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.SystemGeneralApi()
body =  # System_general_update_0 |  (optional)

try: 
    api_instance.system_general_put(body=body)
except ApiException as e:
    print("Exception when calling SystemGeneralApi->systemGeneralPut: %s\n" % e)

Parameters

Body parameters
Name Description
body

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


systemGeneralTimezoneChoicesGet

Returns time zone choices.


/system/general/timezone_choices

Usage and SDK Samples

curl -X GET -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/system/general/timezone_choices"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.SystemGeneralApi;

import java.io.File;
import java.util.*;

public class SystemGeneralApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        SystemGeneralApi apiInstance = new SystemGeneralApi();
        try {
            apiInstance.systemGeneralTimezoneChoicesGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling SystemGeneralApi#systemGeneralTimezoneChoicesGet");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::SystemGeneralApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::SystemGeneralApi->new();

eval { 
    $api_instance->systemGeneralTimezoneChoicesGet();
};
if ($@) {
    warn "Exception when calling SystemGeneralApi->systemGeneralTimezoneChoicesGet: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.SystemGeneralApi()

try: 
    api_instance.system_general_timezone_choices_get()
except ApiException as e:
    print("Exception when calling SystemGeneralApi->systemGeneralTimezoneChoicesGet: %s\n" % e)

Parameters

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


systemGeneralUiAddressChoicesGet

Returns UI ipv4 address choices.


/system/general/ui_address_choices

Usage and SDK Samples

curl -X GET -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/system/general/ui_address_choices"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.SystemGeneralApi;

import java.io.File;
import java.util.*;

public class SystemGeneralApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        SystemGeneralApi apiInstance = new SystemGeneralApi();
        try {
            apiInstance.systemGeneralUiAddressChoicesGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling SystemGeneralApi#systemGeneralUiAddressChoicesGet");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::SystemGeneralApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::SystemGeneralApi->new();

eval { 
    $api_instance->systemGeneralUiAddressChoicesGet();
};
if ($@) {
    warn "Exception when calling SystemGeneralApi->systemGeneralUiAddressChoicesGet: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.SystemGeneralApi()

try: 
    api_instance.system_general_ui_address_choices_get()
except ApiException as e:
    print("Exception when calling SystemGeneralApi->systemGeneralUiAddressChoicesGet: %s\n" % e)

Parameters

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


systemGeneralUiCertificateChoicesGet

Return choices of certificates which can be used for `ui_certificate`.


/system/general/ui_certificate_choices

Usage and SDK Samples

curl -X GET -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/system/general/ui_certificate_choices"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.SystemGeneralApi;

import java.io.File;
import java.util.*;

public class SystemGeneralApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        SystemGeneralApi apiInstance = new SystemGeneralApi();
        try {
            apiInstance.systemGeneralUiCertificateChoicesGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling SystemGeneralApi#systemGeneralUiCertificateChoicesGet");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::SystemGeneralApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::SystemGeneralApi->new();

eval { 
    $api_instance->systemGeneralUiCertificateChoicesGet();
};
if ($@) {
    warn "Exception when calling SystemGeneralApi->systemGeneralUiCertificateChoicesGet: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.SystemGeneralApi()

try: 
    api_instance.system_general_ui_certificate_choices_get()
except ApiException as e:
    print("Exception when calling SystemGeneralApi->systemGeneralUiCertificateChoicesGet: %s\n" % e)

Parameters

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


systemGeneralUiHttpsprotocolsChoicesGet

Returns available HTTPS protocols.


/system/general/ui_httpsprotocols_choices

Usage and SDK Samples

curl -X GET -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/system/general/ui_httpsprotocols_choices"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.SystemGeneralApi;

import java.io.File;
import java.util.*;

public class SystemGeneralApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        SystemGeneralApi apiInstance = new SystemGeneralApi();
        try {
            apiInstance.systemGeneralUiHttpsprotocolsChoicesGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling SystemGeneralApi#systemGeneralUiHttpsprotocolsChoicesGet");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::SystemGeneralApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::SystemGeneralApi->new();

eval { 
    $api_instance->systemGeneralUiHttpsprotocolsChoicesGet();
};
if ($@) {
    warn "Exception when calling SystemGeneralApi->systemGeneralUiHttpsprotocolsChoicesGet: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.SystemGeneralApi()

try: 
    api_instance.system_general_ui_httpsprotocols_choices_get()
except ApiException as e:
    print("Exception when calling SystemGeneralApi->systemGeneralUiHttpsprotocolsChoicesGet: %s\n" % e)

Parameters

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


systemGeneralUiRestartGet

Restart HTTP server to use latest UI settings.


/system/general/ui_restart

Usage and SDK Samples

curl -X GET -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/system/general/ui_restart"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.SystemGeneralApi;

import java.io.File;
import java.util.*;

public class SystemGeneralApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        SystemGeneralApi apiInstance = new SystemGeneralApi();
        try {
            apiInstance.systemGeneralUiRestartGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling SystemGeneralApi#systemGeneralUiRestartGet");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::SystemGeneralApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::SystemGeneralApi->new();

eval { 
    $api_instance->systemGeneralUiRestartGet();
};
if ($@) {
    warn "Exception when calling SystemGeneralApi->systemGeneralUiRestartGet: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.SystemGeneralApi()

try: 
    api_instance.system_general_ui_restart_get()
except ApiException as e:
    print("Exception when calling SystemGeneralApi->systemGeneralUiRestartGet: %s\n" % e)

Parameters

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


systemGeneralUiV6addressChoicesGet

Returns UI ipv6 address choices.


/system/general/ui_v6address_choices

Usage and SDK Samples

curl -X GET -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/system/general/ui_v6address_choices"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.SystemGeneralApi;

import java.io.File;
import java.util.*;

public class SystemGeneralApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        SystemGeneralApi apiInstance = new SystemGeneralApi();
        try {
            apiInstance.systemGeneralUiV6addressChoicesGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling SystemGeneralApi#systemGeneralUiV6addressChoicesGet");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::SystemGeneralApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::SystemGeneralApi->new();

eval { 
    $api_instance->systemGeneralUiV6addressChoicesGet();
};
if ($@) {
    warn "Exception when calling SystemGeneralApi->systemGeneralUiV6addressChoicesGet: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.SystemGeneralApi()

try: 
    api_instance.system_general_ui_v6address_choices_get()
except ApiException as e:
    print("Exception when calling SystemGeneralApi->systemGeneralUiV6addressChoicesGet: %s\n" % e)

Parameters

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


SystemNtpserver

systemNtpserverGet


/system/ntpserver

Usage and SDK Samples

curl -X GET -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/system/ntpserver?limit=&offset=&count=&sort="
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.SystemNtpserverApi;

import java.io.File;
import java.util.*;

public class SystemNtpserverApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        SystemNtpserverApi apiInstance = new SystemNtpserverApi();
        Integer limit = 56; // Integer | 
        Integer offset = 56; // Integer | 
        Boolean count = true; // Boolean | 
        String sort = sort_example; // String | 
        try {
            apiInstance.systemNtpserverGet(limit, offset, count, sort);
        } catch (ApiException e) {
            System.err.println("Exception when calling SystemNtpserverApi#systemNtpserverGet");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::SystemNtpserverApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::SystemNtpserverApi->new();
my $limit = 56; # Integer | 
my $offset = 56; # Integer | 
my $count = true; # Boolean | 
my $sort = sort_example; # String | 

eval { 
    $api_instance->systemNtpserverGet(limit => $limit, offset => $offset, count => $count, sort => $sort);
};
if ($@) {
    warn "Exception when calling SystemNtpserverApi->systemNtpserverGet: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.SystemNtpserverApi()
limit = 56 # Integer |  (optional)
offset = 56 # Integer |  (optional)
count = true # Boolean |  (optional)
sort = sort_example # String |  (optional)

try: 
    api_instance.system_ntpserver_get(limit=limit, offset=offset, count=count, sort=sort)
except ApiException as e:
    print("Exception when calling SystemNtpserverApi->systemNtpserverGet: %s\n" % e)

Parameters

Query parameters
Name Description
limit
Integer
offset
Integer
count
Boolean
sort
String

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


systemNtpserverIdIdDelete

Delete NTP server of `id`.


/system/ntpserver/id/{id}

Usage and SDK Samples

curl -X DELETE -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/system/ntpserver/id/{id}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.SystemNtpserverApi;

import java.io.File;
import java.util.*;

public class SystemNtpserverApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        SystemNtpserverApi apiInstance = new SystemNtpserverApi();
        Integer id = 56; // Integer | 
        try {
            apiInstance.systemNtpserverIdIdDelete(id);
        } catch (ApiException e) {
            System.err.println("Exception when calling SystemNtpserverApi#systemNtpserverIdIdDelete");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::SystemNtpserverApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::SystemNtpserverApi->new();
my $id = 56; # Integer | 

eval { 
    $api_instance->systemNtpserverIdIdDelete(id => $id);
};
if ($@) {
    warn "Exception when calling SystemNtpserverApi->systemNtpserverIdIdDelete: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.SystemNtpserverApi()
id = 56 # Integer | 

try: 
    api_instance.system_ntpserver_id_id_delete(id)
except ApiException as e:
    print("Exception when calling SystemNtpserverApi->systemNtpserverIdIdDelete: %s\n" % e)

Parameters

Path parameters
Name Description
id*
Integer
Required

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


systemNtpserverIdIdGet


/system/ntpserver/id/{id}

Usage and SDK Samples

curl -X GET -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/system/ntpserver/id/{id}?limit=&offset=&count=&sort="
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.SystemNtpserverApi;

import java.io.File;
import java.util.*;

public class SystemNtpserverApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        SystemNtpserverApi apiInstance = new SystemNtpserverApi();
        array[null] id = ; // array[null] | 
        Integer limit = 56; // Integer | 
        Integer offset = 56; // Integer | 
        Boolean count = true; // Boolean | 
        String sort = sort_example; // String | 
        try {
            apiInstance.systemNtpserverIdIdGet(id, limit, offset, count, sort);
        } catch (ApiException e) {
            System.err.println("Exception when calling SystemNtpserverApi#systemNtpserverIdIdGet");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::SystemNtpserverApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::SystemNtpserverApi->new();
my $id = []; # array[null] | 
my $limit = 56; # Integer | 
my $offset = 56; # Integer | 
my $count = true; # Boolean | 
my $sort = sort_example; # String | 

eval { 
    $api_instance->systemNtpserverIdIdGet(id => $id, limit => $limit, offset => $offset, count => $count, sort => $sort);
};
if ($@) {
    warn "Exception when calling SystemNtpserverApi->systemNtpserverIdIdGet: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.SystemNtpserverApi()
id =  # array[null] | 
limit = 56 # Integer |  (optional)
offset = 56 # Integer |  (optional)
count = true # Boolean |  (optional)
sort = sort_example # String |  (optional)

try: 
    api_instance.system_ntpserver_id_id_get(id, limit=limit, offset=offset, count=count, sort=sort)
except ApiException as e:
    print("Exception when calling SystemNtpserverApi->systemNtpserverIdIdGet: %s\n" % e)

Parameters

Path parameters
Name Description
id*
array[null]
Required
Query parameters
Name Description
limit
Integer
offset
Integer
count
Boolean
sort
String

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


systemNtpserverIdIdPut

Update NTP server of `id`.


/system/ntpserver/id/{id}

Usage and SDK Samples

curl -X PUT -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/system/ntpserver/id/{id}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.SystemNtpserverApi;

import java.io.File;
import java.util.*;

public class SystemNtpserverApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        SystemNtpserverApi apiInstance = new SystemNtpserverApi();
        Integer id = 56; // Integer | 
        System_ntpserver_update_1 body = ; // System_ntpserver_update_1 | 
        try {
            apiInstance.systemNtpserverIdIdPut(id, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling SystemNtpserverApi#systemNtpserverIdIdPut");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::SystemNtpserverApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::SystemNtpserverApi->new();
my $id = 56; # Integer | 
my $body = WWW::SwaggerClient::Object::System_ntpserver_update_1->new(); # System_ntpserver_update_1 | 

eval { 
    $api_instance->systemNtpserverIdIdPut(id => $id, body => $body);
};
if ($@) {
    warn "Exception when calling SystemNtpserverApi->systemNtpserverIdIdPut: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.SystemNtpserverApi()
id = 56 # Integer | 
body =  # System_ntpserver_update_1 |  (optional)

try: 
    api_instance.system_ntpserver_id_id_put(id, body=body)
except ApiException as e:
    print("Exception when calling SystemNtpserverApi->systemNtpserverIdIdPut: %s\n" % e)

Parameters

Path parameters
Name Description
id*
Integer
Required
Body parameters
Name Description
body

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


systemNtpserverPost

Add an NTP Server. `address` specifies the hostname/IP address of the NTP server. `burst` when enabled makes sure that if server is reachable, sends a burst of eight packets instead of one. This is designed to improve timekeeping quality with the server command. `iburst` when enabled speeds up the initial synchronization, taking seconds rather than minutes. `prefer` marks the specified server as preferred. When all other things are equal, this host is chosen for synchronization acquisition with the server command. It is recommended that they be used for servers with time monitoring hardware. `minpoll` is minimum polling time in seconds. It must be a power of 2 and less than `maxpoll`. `maxpoll` is maximum polling time in seconds. It must be a power of 2 and greater than `minpoll`. `force` when enabled forces the addition of NTP server even if it is currently unreachable.


/system/ntpserver

Usage and SDK Samples

curl -X POST -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/system/ntpserver"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.SystemNtpserverApi;

import java.io.File;
import java.util.*;

public class SystemNtpserverApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        SystemNtpserverApi apiInstance = new SystemNtpserverApi();
        System_ntpserver_create_0 body = ; // System_ntpserver_create_0 | 
        try {
            apiInstance.systemNtpserverPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling SystemNtpserverApi#systemNtpserverPost");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::SystemNtpserverApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::SystemNtpserverApi->new();
my $body = WWW::SwaggerClient::Object::System_ntpserver_create_0->new(); # System_ntpserver_create_0 | 

eval { 
    $api_instance->systemNtpserverPost(body => $body);
};
if ($@) {
    warn "Exception when calling SystemNtpserverApi->systemNtpserverPost: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.SystemNtpserverApi()
body =  # System_ntpserver_create_0 |  (optional)

try: 
    api_instance.system_ntpserver_post(body=body)
except ApiException as e:
    print("Exception when calling SystemNtpserverApi->systemNtpserverPost: %s\n" % e)

Parameters

Body parameters
Name Description
body

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


systemNtpserverTestNtpServerGet


/system/ntpserver/test_ntp_server

Usage and SDK Samples

curl -X GET -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/system/ntpserver/test_ntp_server"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.SystemNtpserverApi;

import java.io.File;
import java.util.*;

public class SystemNtpserverApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        SystemNtpserverApi apiInstance = new SystemNtpserverApi();
        try {
            apiInstance.systemNtpserverTestNtpServerGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling SystemNtpserverApi#systemNtpserverTestNtpServerGet");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::SystemNtpserverApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::SystemNtpserverApi->new();

eval { 
    $api_instance->systemNtpserverTestNtpServerGet();
};
if ($@) {
    warn "Exception when calling SystemNtpserverApi->systemNtpserverTestNtpServerGet: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.SystemNtpserverApi()

try: 
    api_instance.system_ntpserver_test_ntp_server_get()
except ApiException as e:
    print("Exception when calling SystemNtpserverApi->systemNtpserverTestNtpServerGet: %s\n" % e)

Parameters

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


Systemdataset

systemdatasetGet


/systemdataset

Usage and SDK Samples

curl -X GET -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/systemdataset"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.SystemdatasetApi;

import java.io.File;
import java.util.*;

public class SystemdatasetApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        SystemdatasetApi apiInstance = new SystemdatasetApi();
        try {
            apiInstance.systemdatasetGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling SystemdatasetApi#systemdatasetGet");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::SystemdatasetApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::SystemdatasetApi->new();

eval { 
    $api_instance->systemdatasetGet();
};
if ($@) {
    warn "Exception when calling SystemdatasetApi->systemdatasetGet: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.SystemdatasetApi()

try: 
    api_instance.systemdataset_get()
except ApiException as e:
    print("Exception when calling SystemdatasetApi->systemdatasetGet: %s\n" % e)

Parameters

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


systemdatasetPut

Update System Dataset Service Configuration. `pool` is the name of a valid pool configured in the system which will be used to host the system dataset. `pool_exclude` can be specified to make sure that we don't place the system dataset on that pool if `pool` is not provided.


/systemdataset

Usage and SDK Samples

curl -X PUT -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/systemdataset"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.SystemdatasetApi;

import java.io.File;
import java.util.*;

public class SystemdatasetApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        SystemdatasetApi apiInstance = new SystemdatasetApi();
        Systemdataset_update_0 body = ; // Systemdataset_update_0 | 
        try {
            apiInstance.systemdatasetPut(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling SystemdatasetApi#systemdatasetPut");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::SystemdatasetApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::SystemdatasetApi->new();
my $body = WWW::SwaggerClient::Object::Systemdataset_update_0->new(); # Systemdataset_update_0 | 

eval { 
    $api_instance->systemdatasetPut(body => $body);
};
if ($@) {
    warn "Exception when calling SystemdatasetApi->systemdatasetPut: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.SystemdatasetApi()
body =  # Systemdataset_update_0 |  (optional)

try: 
    api_instance.systemdataset_put(body=body)
except ApiException as e:
    print("Exception when calling SystemdatasetApi->systemdatasetPut: %s\n" % e)

Parameters

Body parameters
Name Description
body

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


Taskpath

taskpathGet


/taskpath

Usage and SDK Samples

curl -X GET -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/taskpath?limit=&offset=&count=&sort="
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.TaskpathApi;

import java.io.File;
import java.util.*;

public class TaskpathApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        TaskpathApi apiInstance = new TaskpathApi();
        Integer limit = 56; // Integer | 
        Integer offset = 56; // Integer | 
        Boolean count = true; // Boolean | 
        String sort = sort_example; // String | 
        try {
            apiInstance.taskpathGet(limit, offset, count, sort);
        } catch (ApiException e) {
            System.err.println("Exception when calling TaskpathApi#taskpathGet");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::TaskpathApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::TaskpathApi->new();
my $limit = 56; # Integer | 
my $offset = 56; # Integer | 
my $count = true; # Boolean | 
my $sort = sort_example; # String | 

eval { 
    $api_instance->taskpathGet(limit => $limit, offset => $offset, count => $count, sort => $sort);
};
if ($@) {
    warn "Exception when calling TaskpathApi->taskpathGet: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.TaskpathApi()
limit = 56 # Integer |  (optional)
offset = 56 # Integer |  (optional)
count = true # Boolean |  (optional)
sort = sort_example # String |  (optional)

try: 
    api_instance.taskpath_get(limit=limit, offset=offset, count=count, sort=sort)
except ApiException as e:
    print("Exception when calling TaskpathApi->taskpathGet: %s\n" % e)

Parameters

Query parameters
Name Description
limit
Integer
offset
Integer
count
Boolean
sort
String

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


taskpathIdIdGet


/taskpath/id/{id}

Usage and SDK Samples

curl -X GET -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/taskpath/id/{id}?limit=&offset=&count=&sort="
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.TaskpathApi;

import java.io.File;
import java.util.*;

public class TaskpathApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        TaskpathApi apiInstance = new TaskpathApi();
        array[null] id = ; // array[null] | 
        Integer limit = 56; // Integer | 
        Integer offset = 56; // Integer | 
        Boolean count = true; // Boolean | 
        String sort = sort_example; // String | 
        try {
            apiInstance.taskpathIdIdGet(id, limit, offset, count, sort);
        } catch (ApiException e) {
            System.err.println("Exception when calling TaskpathApi#taskpathIdIdGet");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::TaskpathApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::TaskpathApi->new();
my $id = []; # array[null] | 
my $limit = 56; # Integer | 
my $offset = 56; # Integer | 
my $count = true; # Boolean | 
my $sort = sort_example; # String | 

eval { 
    $api_instance->taskpathIdIdGet(id => $id, limit => $limit, offset => $offset, count => $count, sort => $sort);
};
if ($@) {
    warn "Exception when calling TaskpathApi->taskpathIdIdGet: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.TaskpathApi()
id =  # array[null] | 
limit = 56 # Integer |  (optional)
offset = 56 # Integer |  (optional)
count = true # Boolean |  (optional)
sort = sort_example # String |  (optional)

try: 
    api_instance.taskpath_id_id_get(id, limit=limit, offset=offset, count=count, sort=sort)
except ApiException as e:
    print("Exception when calling TaskpathApi->taskpathIdIdGet: %s\n" % e)

Parameters

Path parameters
Name Description
id*
array[null]
Required
Query parameters
Name Description
limit
Integer
offset
Integer
count
Boolean
sort
String

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


Tftp

tftpGet


/tftp

Usage and SDK Samples

curl -X GET -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/tftp"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.TftpApi;

import java.io.File;
import java.util.*;

public class TftpApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        TftpApi apiInstance = new TftpApi();
        try {
            apiInstance.tftpGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling TftpApi#tftpGet");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::TftpApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::TftpApi->new();

eval { 
    $api_instance->tftpGet();
};
if ($@) {
    warn "Exception when calling TftpApi->tftpGet: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.TftpApi()

try: 
    api_instance.tftp_get()
except ApiException as e:
    print("Exception when calling TftpApi->tftpGet: %s\n" % e)

Parameters

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


tftpPut

Update TFTP Service Configuration. `newfiles` when set enables network devices to send files to the system. `username` sets the user account which will be used to access `directory`. It should be ensured `username` has access to `directory`.


/tftp

Usage and SDK Samples

curl -X PUT -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/tftp"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.TftpApi;

import java.io.File;
import java.util.*;

public class TftpApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        TftpApi apiInstance = new TftpApi();
        Tftp_update_0 body = ; // Tftp_update_0 | 
        try {
            apiInstance.tftpPut(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling TftpApi#tftpPut");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::TftpApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::TftpApi->new();
my $body = WWW::SwaggerClient::Object::Tftp_update_0->new(); # Tftp_update_0 | 

eval { 
    $api_instance->tftpPut(body => $body);
};
if ($@) {
    warn "Exception when calling TftpApi->tftpPut: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.TftpApi()
body =  # Tftp_update_0 |  (optional)

try: 
    api_instance.tftp_put(body=body)
except ApiException as e:
    print("Exception when calling TftpApi->tftpPut: %s\n" % e)

Parameters

Body parameters
Name Description
body

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


Truecommand

truecommandGet


/truecommand

Usage and SDK Samples

curl -X GET -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/truecommand"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.TruecommandApi;

import java.io.File;
import java.util.*;

public class TruecommandApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        TruecommandApi apiInstance = new TruecommandApi();
        try {
            apiInstance.truecommandGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling TruecommandApi#truecommandGet");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::TruecommandApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::TruecommandApi->new();

eval { 
    $api_instance->truecommandGet();
};
if ($@) {
    warn "Exception when calling TruecommandApi->truecommandGet: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.TruecommandApi()

try: 
    api_instance.truecommand_get()
except ApiException as e:
    print("Exception when calling TruecommandApi->truecommandGet: %s\n" % e)

Parameters

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


truecommandPut

Update Truecommand service settings. `api_key` is a valid API key generated by iX Portal.


/truecommand

Usage and SDK Samples

curl -X PUT -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/truecommand"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.TruecommandApi;

import java.io.File;
import java.util.*;

public class TruecommandApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        TruecommandApi apiInstance = new TruecommandApi();
        Truecommand_update_0 body = ; // Truecommand_update_0 | 
        try {
            apiInstance.truecommandPut(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling TruecommandApi#truecommandPut");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::TruecommandApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::TruecommandApi->new();
my $body = WWW::SwaggerClient::Object::Truecommand_update_0->new(); # Truecommand_update_0 | 

eval { 
    $api_instance->truecommandPut(body => $body);
};
if ($@) {
    warn "Exception when calling TruecommandApi->truecommandPut: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.TruecommandApi()
body =  # Truecommand_update_0 |  (optional)

try: 
    api_instance.truecommand_put(body=body)
except ApiException as e:
    print("Exception when calling TruecommandApi->truecommandPut: %s\n" % e)

Parameters

Body parameters
Name Description
body

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


Truenas

truenasAcceptEulaGet

Accept TrueNAS EULA.


/truenas/accept_eula

Usage and SDK Samples

curl -X GET -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/truenas/accept_eula"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.TruenasApi;

import java.io.File;
import java.util.*;

public class TruenasApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        TruenasApi apiInstance = new TruenasApi();
        try {
            apiInstance.truenasAcceptEulaGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling TruenasApi#truenasAcceptEulaGet");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::TruenasApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::TruenasApi->new();

eval { 
    $api_instance->truenasAcceptEulaGet();
};
if ($@) {
    warn "Exception when calling TruenasApi->truenasAcceptEulaGet: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.TruenasApi()

try: 
    api_instance.truenas_accept_eula_get()
except ApiException as e:
    print("Exception when calling TruenasApi->truenasAcceptEulaGet: %s\n" % e)

Parameters

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


truenasGetChassisHardwareGet

Returns what type of hardware this is, detected from dmidecode. TRUENAS-X10-HA-D TRUENAS-X10-S TRUENAS-X20-HA-D TRUENAS-X20-S TRUENAS-M40-HA TRUENAS-M40-S TRUENAS-M50-HA TRUENAS-M50-S TRUENAS-M60-HA TRUENAS-M60-S TRUENAS-Z20-S TRUENAS-Z20-HA-D TRUENAS-Z30-HA-D TRUENAS-Z30-S TRUENAS-Z35-HA-D TRUENAS-Z35-S TRUENAS-Z50-HA-D TRUENAS-Z50-S Nothing in dmidecode but a M, X or Z class machine: (Note this means production didn't burn the hardware model into SMBIOS. We can detect this case by looking at the motherboard) TRUENAS-M TRUENAS-X TRUENAS-Z Detected by the motherboard model: TRUENAS-SBB Pretty much anything else with a SM X8 board: (X8DTH was popular but there are a few other boards out there) TRUENAS-SM Really NFI about hardware at this point. TrueNAS on a Dell? TRUENAS-UNKNOWN


/truenas/get_chassis_hardware

Usage and SDK Samples

curl -X GET -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/truenas/get_chassis_hardware"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.TruenasApi;

import java.io.File;
import java.util.*;

public class TruenasApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        TruenasApi apiInstance = new TruenasApi();
        try {
            apiInstance.truenasGetChassisHardwareGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling TruenasApi#truenasGetChassisHardwareGet");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::TruenasApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::TruenasApi->new();

eval { 
    $api_instance->truenasGetChassisHardwareGet();
};
if ($@) {
    warn "Exception when calling TruenasApi->truenasGetChassisHardwareGet: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.TruenasApi()

try: 
    api_instance.truenas_get_chassis_hardware_get()
except ApiException as e:
    print("Exception when calling TruenasApi->truenasGetChassisHardwareGet: %s\n" % e)

Parameters

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


truenasGetCustomerInformationGet

Returns stored customer information.


/truenas/get_customer_information

Usage and SDK Samples

curl -X GET -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/truenas/get_customer_information"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.TruenasApi;

import java.io.File;
import java.util.*;

public class TruenasApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        TruenasApi apiInstance = new TruenasApi();
        try {
            apiInstance.truenasGetCustomerInformationGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling TruenasApi#truenasGetCustomerInformationGet");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::TruenasApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::TruenasApi->new();

eval { 
    $api_instance->truenasGetCustomerInformationGet();
};
if ($@) {
    warn "Exception when calling TruenasApi->truenasGetCustomerInformationGet: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.TruenasApi()

try: 
    api_instance.truenas_get_customer_information_get()
except ApiException as e:
    print("Exception when calling TruenasApi->truenasGetCustomerInformationGet: %s\n" % e)

Parameters

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


truenasGetEulaGet

Returns the TrueNAS End-User License Agreement (EULA).


/truenas/get_eula

Usage and SDK Samples

curl -X GET -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/truenas/get_eula"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.TruenasApi;

import java.io.File;
import java.util.*;

public class TruenasApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        TruenasApi apiInstance = new TruenasApi();
        try {
            apiInstance.truenasGetEulaGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling TruenasApi#truenasGetEulaGet");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::TruenasApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::TruenasApi->new();

eval { 
    $api_instance->truenasGetEulaGet();
};
if ($@) {
    warn "Exception when calling TruenasApi->truenasGetEulaGet: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.TruenasApi()

try: 
    api_instance.truenas_get_eula_get()
except ApiException as e:
    print("Exception when calling TruenasApi->truenasGetEulaGet: %s\n" % e)

Parameters

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


truenasIsEulaAcceptedGet

Returns whether the EULA is accepted or not.


/truenas/is_eula_accepted

Usage and SDK Samples

curl -X GET -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/truenas/is_eula_accepted"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.TruenasApi;

import java.io.File;
import java.util.*;

public class TruenasApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        TruenasApi apiInstance = new TruenasApi();
        try {
            apiInstance.truenasIsEulaAcceptedGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling TruenasApi#truenasIsEulaAcceptedGet");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::TruenasApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::TruenasApi->new();

eval { 
    $api_instance->truenasIsEulaAcceptedGet();
};
if ($@) {
    warn "Exception when calling TruenasApi->truenasIsEulaAcceptedGet: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.TruenasApi()

try: 
    api_instance.truenas_is_eula_accepted_get()
except ApiException as e:
    print("Exception when calling TruenasApi->truenasIsEulaAcceptedGet: %s\n" % e)

Parameters

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


truenasIsProductionGet

Returns if system is marked as production.


/truenas/is_production

Usage and SDK Samples

curl -X GET -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/truenas/is_production"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.TruenasApi;

import java.io.File;
import java.util.*;

public class TruenasApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        TruenasApi apiInstance = new TruenasApi();
        try {
            apiInstance.truenasIsProductionGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling TruenasApi#truenasIsProductionGet");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::TruenasApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::TruenasApi->new();

eval { 
    $api_instance->truenasIsProductionGet();
};
if ($@) {
    warn "Exception when calling TruenasApi->truenasIsProductionGet: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.TruenasApi()

try: 
    api_instance.truenas_is_production_get()
except ApiException as e:
    print("Exception when calling TruenasApi->truenasIsProductionGet: %s\n" % e)

Parameters

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


truenasSetProductionPost

Sets system production state and optionally sends initial debug.


/truenas/set_production

Usage and SDK Samples

curl -X POST -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/truenas/set_production"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.TruenasApi;

import java.io.File;
import java.util.*;

public class TruenasApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        TruenasApi apiInstance = new TruenasApi();
        Truenas_set_production body = ; // Truenas_set_production | 
        try {
            apiInstance.truenasSetProductionPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling TruenasApi#truenasSetProductionPost");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::TruenasApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::TruenasApi->new();
my $body = WWW::SwaggerClient::Object::Truenas_set_production->new(); # Truenas_set_production | 

eval { 
    $api_instance->truenasSetProductionPost(body => $body);
};
if ($@) {
    warn "Exception when calling TruenasApi->truenasSetProductionPost: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.TruenasApi()
body =  # Truenas_set_production |  (optional)

try: 
    api_instance.truenas_set_production_post(body=body)
except ApiException as e:
    print("Exception when calling TruenasApi->truenasSetProductionPost: %s\n" % e)

Parameters

Body parameters
Name Description
body

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


truenasUpdateCustomerInformationPost

Updates customer information.


/truenas/update_customer_information

Usage and SDK Samples

curl -X POST -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/truenas/update_customer_information"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.TruenasApi;

import java.io.File;
import java.util.*;

public class TruenasApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        TruenasApi apiInstance = new TruenasApi();
        Truenas_update_customer_information_0 body = ; // Truenas_update_customer_information_0 | 
        try {
            apiInstance.truenasUpdateCustomerInformationPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling TruenasApi#truenasUpdateCustomerInformationPost");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::TruenasApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::TruenasApi->new();
my $body = WWW::SwaggerClient::Object::Truenas_update_customer_information_0->new(); # Truenas_update_customer_information_0 | 

eval { 
    $api_instance->truenasUpdateCustomerInformationPost(body => $body);
};
if ($@) {
    warn "Exception when calling TruenasApi->truenasUpdateCustomerInformationPost: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.TruenasApi()
body =  # Truenas_update_customer_information_0 |  (optional)

try: 
    api_instance.truenas_update_customer_information_post(body=body)
except ApiException as e:
    print("Exception when calling TruenasApi->truenasUpdateCustomerInformationPost: %s\n" % e)

Parameters

Body parameters
Name Description
body

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


Tunable

tunableGet


/tunable

Usage and SDK Samples

curl -X GET -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/tunable?limit=&offset=&count=&sort="
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.TunableApi;

import java.io.File;
import java.util.*;

public class TunableApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        TunableApi apiInstance = new TunableApi();
        Integer limit = 56; // Integer | 
        Integer offset = 56; // Integer | 
        Boolean count = true; // Boolean | 
        String sort = sort_example; // String | 
        try {
            apiInstance.tunableGet(limit, offset, count, sort);
        } catch (ApiException e) {
            System.err.println("Exception when calling TunableApi#tunableGet");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::TunableApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::TunableApi->new();
my $limit = 56; # Integer | 
my $offset = 56; # Integer | 
my $count = true; # Boolean | 
my $sort = sort_example; # String | 

eval { 
    $api_instance->tunableGet(limit => $limit, offset => $offset, count => $count, sort => $sort);
};
if ($@) {
    warn "Exception when calling TunableApi->tunableGet: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.TunableApi()
limit = 56 # Integer |  (optional)
offset = 56 # Integer |  (optional)
count = true # Boolean |  (optional)
sort = sort_example # String |  (optional)

try: 
    api_instance.tunable_get(limit=limit, offset=offset, count=count, sort=sort)
except ApiException as e:
    print("Exception when calling TunableApi->tunableGet: %s\n" % e)

Parameters

Query parameters
Name Description
limit
Integer
offset
Integer
count
Boolean
sort
String

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


tunableIdIdDelete

Delete Tunable of `id`.


/tunable/id/{id}

Usage and SDK Samples

curl -X DELETE -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/tunable/id/{id}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.TunableApi;

import java.io.File;
import java.util.*;

public class TunableApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        TunableApi apiInstance = new TunableApi();
        Integer id = 56; // Integer | 
        try {
            apiInstance.tunableIdIdDelete(id);
        } catch (ApiException e) {
            System.err.println("Exception when calling TunableApi#tunableIdIdDelete");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::TunableApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::TunableApi->new();
my $id = 56; # Integer | 

eval { 
    $api_instance->tunableIdIdDelete(id => $id);
};
if ($@) {
    warn "Exception when calling TunableApi->tunableIdIdDelete: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.TunableApi()
id = 56 # Integer | 

try: 
    api_instance.tunable_id_id_delete(id)
except ApiException as e:
    print("Exception when calling TunableApi->tunableIdIdDelete: %s\n" % e)

Parameters

Path parameters
Name Description
id*
Integer
Required

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


tunableIdIdGet


/tunable/id/{id}

Usage and SDK Samples

curl -X GET -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/tunable/id/{id}?limit=&offset=&count=&sort="
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.TunableApi;

import java.io.File;
import java.util.*;

public class TunableApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        TunableApi apiInstance = new TunableApi();
        array[null] id = ; // array[null] | 
        Integer limit = 56; // Integer | 
        Integer offset = 56; // Integer | 
        Boolean count = true; // Boolean | 
        String sort = sort_example; // String | 
        try {
            apiInstance.tunableIdIdGet(id, limit, offset, count, sort);
        } catch (ApiException e) {
            System.err.println("Exception when calling TunableApi#tunableIdIdGet");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::TunableApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::TunableApi->new();
my $id = []; # array[null] | 
my $limit = 56; # Integer | 
my $offset = 56; # Integer | 
my $count = true; # Boolean | 
my $sort = sort_example; # String | 

eval { 
    $api_instance->tunableIdIdGet(id => $id, limit => $limit, offset => $offset, count => $count, sort => $sort);
};
if ($@) {
    warn "Exception when calling TunableApi->tunableIdIdGet: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.TunableApi()
id =  # array[null] | 
limit = 56 # Integer |  (optional)
offset = 56 # Integer |  (optional)
count = true # Boolean |  (optional)
sort = sort_example # String |  (optional)

try: 
    api_instance.tunable_id_id_get(id, limit=limit, offset=offset, count=count, sort=sort)
except ApiException as e:
    print("Exception when calling TunableApi->tunableIdIdGet: %s\n" % e)

Parameters

Path parameters
Name Description
id*
array[null]
Required
Query parameters
Name Description
limit
Integer
offset
Integer
count
Boolean
sort
String

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


tunableIdIdPut

Update Tunable of `id`.


/tunable/id/{id}

Usage and SDK Samples

curl -X PUT -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/tunable/id/{id}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.TunableApi;

import java.io.File;
import java.util.*;

public class TunableApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        TunableApi apiInstance = new TunableApi();
        Integer id = 56; // Integer | 
        Tunable_update_1 body = ; // Tunable_update_1 | 
        try {
            apiInstance.tunableIdIdPut(id, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling TunableApi#tunableIdIdPut");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::TunableApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::TunableApi->new();
my $id = 56; # Integer | 
my $body = WWW::SwaggerClient::Object::Tunable_update_1->new(); # Tunable_update_1 | 

eval { 
    $api_instance->tunableIdIdPut(id => $id, body => $body);
};
if ($@) {
    warn "Exception when calling TunableApi->tunableIdIdPut: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.TunableApi()
id = 56 # Integer | 
body =  # Tunable_update_1 |  (optional)

try: 
    api_instance.tunable_id_id_put(id, body=body)
except ApiException as e:
    print("Exception when calling TunableApi->tunableIdIdPut: %s\n" % e)

Parameters

Path parameters
Name Description
id*
Integer
Required
Body parameters
Name Description
body

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


tunablePost

Create a Tunable. `var` represents name of the sysctl/loader/rc variable. `type` for SCALE should be one of the following: 1) SYSCTL - Configure `var` for sysctl(8) `type` for CORE/ENTERPRISE should be one of the following: 1) LOADER - Configure `var` for loader(8) 2) RC - Configure `var` for rc(8) 3) SYSCTL - Configure `var` for sysctl(8)


/tunable

Usage and SDK Samples

curl -X POST -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/tunable"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.TunableApi;

import java.io.File;
import java.util.*;

public class TunableApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        TunableApi apiInstance = new TunableApi();
        Tunable_create_0 body = ; // Tunable_create_0 | 
        try {
            apiInstance.tunablePost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling TunableApi#tunablePost");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::TunableApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::TunableApi->new();
my $body = WWW::SwaggerClient::Object::Tunable_create_0->new(); # Tunable_create_0 | 

eval { 
    $api_instance->tunablePost(body => $body);
};
if ($@) {
    warn "Exception when calling TunableApi->tunablePost: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.TunableApi()
body =  # Tunable_create_0 |  (optional)

try: 
    api_instance.tunable_post(body=body)
except ApiException as e:
    print("Exception when calling TunableApi->tunablePost: %s\n" % e)

Parameters

Body parameters
Name Description
body

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


tunableTunableTypeChoicesGet

Retrieve tunable type choices supported in the system


/tunable/tunable_type_choices

Usage and SDK Samples

curl -X GET -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/tunable/tunable_type_choices"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.TunableApi;

import java.io.File;
import java.util.*;

public class TunableApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        TunableApi apiInstance = new TunableApi();
        try {
            apiInstance.tunableTunableTypeChoicesGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling TunableApi#tunableTunableTypeChoicesGet");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::TunableApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::TunableApi->new();

eval { 
    $api_instance->tunableTunableTypeChoicesGet();
};
if ($@) {
    warn "Exception when calling TunableApi->tunableTunableTypeChoicesGet: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.TunableApi()

try: 
    api_instance.tunable_tunable_type_choices_get()
except ApiException as e:
    print("Exception when calling TunableApi->tunableTunableTypeChoicesGet: %s\n" % e)

Parameters

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


Update

updateCheckAvailablePost

Checks if there is an update available from update server. status: - REBOOT_REQUIRED: an update has already been applied - AVAILABLE: an update is available - UNAVAILABLE: no update available - HA_UNAVAILABLE: HA is non-functional


/update/check_available

Usage and SDK Samples

curl -X POST -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/update/check_available"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.UpdateApi;

import java.io.File;
import java.util.*;

public class UpdateApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        UpdateApi apiInstance = new UpdateApi();
        Update_check_available_0 body = ; // Update_check_available_0 | 
        try {
            apiInstance.updateCheckAvailablePost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling UpdateApi#updateCheckAvailablePost");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::UpdateApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::UpdateApi->new();
my $body = WWW::SwaggerClient::Object::Update_check_available_0->new(); # Update_check_available_0 | 

eval { 
    $api_instance->updateCheckAvailablePost(body => $body);
};
if ($@) {
    warn "Exception when calling UpdateApi->updateCheckAvailablePost: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.UpdateApi()
body =  # Update_check_available_0 |  (optional)

try: 
    api_instance.update_check_available_post(body=body)
except ApiException as e:
    print("Exception when calling UpdateApi->updateCheckAvailablePost: %s\n" % e)

Parameters

Body parameters
Name Description
body

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


updateDownloadGet

Download updates using selected train.


/update/download

Usage and SDK Samples

curl -X GET -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/update/download"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.UpdateApi;

import java.io.File;
import java.util.*;

public class UpdateApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        UpdateApi apiInstance = new UpdateApi();
        try {
            apiInstance.updateDownloadGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling UpdateApi#updateDownloadGet");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::UpdateApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::UpdateApi->new();

eval { 
    $api_instance->updateDownloadGet();
};
if ($@) {
    warn "Exception when calling UpdateApi->updateDownloadGet: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.UpdateApi()

try: 
    api_instance.update_download_get()
except ApiException as e:
    print("Exception when calling UpdateApi->updateDownloadGet: %s\n" % e)

Parameters

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


updateGetAutoDownloadGet

Returns if update auto-download is enabled.


/update/get_auto_download

Usage and SDK Samples

curl -X GET -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/update/get_auto_download"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.UpdateApi;

import java.io.File;
import java.util.*;

public class UpdateApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        UpdateApi apiInstance = new UpdateApi();
        try {
            apiInstance.updateGetAutoDownloadGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling UpdateApi#updateGetAutoDownloadGet");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::UpdateApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::UpdateApi->new();

eval { 
    $api_instance->updateGetAutoDownloadGet();
};
if ($@) {
    warn "Exception when calling UpdateApi->updateGetAutoDownloadGet: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.UpdateApi()

try: 
    api_instance.update_get_auto_download_get()
except ApiException as e:
    print("Exception when calling UpdateApi->updateGetAutoDownloadGet: %s\n" % e)

Parameters

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


updateGetPendingPost

Gets a list of packages already downloaded and ready to be applied. Each entry of the lists consists of type of operation and name of it, e.g. { "operation": "upgrade", "name": "baseos-11.0 -> baseos-11.1" }


/update/get_pending

Usage and SDK Samples

curl -X POST -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/update/get_pending"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.UpdateApi;

import java.io.File;
import java.util.*;

public class UpdateApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        UpdateApi apiInstance = new UpdateApi();
        String body = ; // String | 
        try {
            apiInstance.updateGetPendingPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling UpdateApi#updateGetPendingPost");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::UpdateApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::UpdateApi->new();
my $body = WWW::SwaggerClient::Object::String->new(); # String | 

eval { 
    $api_instance->updateGetPendingPost(body => $body);
};
if ($@) {
    warn "Exception when calling UpdateApi->updateGetPendingPost: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.UpdateApi()
body =  # String |  (optional)

try: 
    api_instance.update_get_pending_post(body=body)
except ApiException as e:
    print("Exception when calling UpdateApi->updateGetPendingPost: %s\n" % e)

Parameters

Body parameters
Name Description
body

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


updateGetTrainsGet

Returns available trains dict and the currently configured train as well as the train of currently booted environment.


/update/get_trains

Usage and SDK Samples

curl -X GET -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/update/get_trains"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.UpdateApi;

import java.io.File;
import java.util.*;

public class UpdateApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        UpdateApi apiInstance = new UpdateApi();
        try {
            apiInstance.updateGetTrainsGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling UpdateApi#updateGetTrainsGet");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::UpdateApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::UpdateApi->new();

eval { 
    $api_instance->updateGetTrainsGet();
};
if ($@) {
    warn "Exception when calling UpdateApi->updateGetTrainsGet: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.UpdateApi()

try: 
    api_instance.update_get_trains_get()
except ApiException as e:
    print("Exception when calling UpdateApi->updateGetTrainsGet: %s\n" % e)

Parameters

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


updateManualPost

Apply manual update of file `path`.


/update/manual

Usage and SDK Samples

curl -X POST -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/update/manual"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.UpdateApi;

import java.io.File;
import java.util.*;

public class UpdateApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        UpdateApi apiInstance = new UpdateApi();
        String body = ; // String | 
        try {
            apiInstance.updateManualPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling UpdateApi#updateManualPost");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::UpdateApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::UpdateApi->new();
my $body = WWW::SwaggerClient::Object::String->new(); # String | 

eval { 
    $api_instance->updateManualPost(body => $body);
};
if ($@) {
    warn "Exception when calling UpdateApi->updateManualPost: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.UpdateApi()
body =  # String |  (optional)

try: 
    api_instance.update_manual_post(body=body)
except ApiException as e:
    print("Exception when calling UpdateApi->updateManualPost: %s\n" % e)

Parameters

Body parameters
Name Description
body

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


updateSetAutoDownloadPost

Sets if update auto-download is enabled.


/update/set_auto_download

Usage and SDK Samples

curl -X POST -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/update/set_auto_download"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.UpdateApi;

import java.io.File;
import java.util.*;

public class UpdateApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        UpdateApi apiInstance = new UpdateApi();
        Boolean body = ; // Boolean | 
        try {
            apiInstance.updateSetAutoDownloadPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling UpdateApi#updateSetAutoDownloadPost");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::UpdateApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::UpdateApi->new();
my $body = WWW::SwaggerClient::Object::Boolean->new(); # Boolean | 

eval { 
    $api_instance->updateSetAutoDownloadPost(body => $body);
};
if ($@) {
    warn "Exception when calling UpdateApi->updateSetAutoDownloadPost: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.UpdateApi()
body =  # Boolean |  (optional)

try: 
    api_instance.update_set_auto_download_post(body=body)
except ApiException as e:
    print("Exception when calling UpdateApi->updateSetAutoDownloadPost: %s\n" % e)

Parameters

Body parameters
Name Description
body

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


updateSetTrainPost

Set an update train to be used by default in updates.


/update/set_train

Usage and SDK Samples

curl -X POST -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/update/set_train"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.UpdateApi;

import java.io.File;
import java.util.*;

public class UpdateApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        UpdateApi apiInstance = new UpdateApi();
        String body = ; // String | 
        try {
            apiInstance.updateSetTrainPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling UpdateApi#updateSetTrainPost");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::UpdateApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::UpdateApi->new();
my $body = WWW::SwaggerClient::Object::String->new(); # String | 

eval { 
    $api_instance->updateSetTrainPost(body => $body);
};
if ($@) {
    warn "Exception when calling UpdateApi->updateSetTrainPost: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.UpdateApi()
body =  # String |  (optional)

try: 
    api_instance.update_set_train_post(body=body)
except ApiException as e:
    print("Exception when calling UpdateApi->updateSetTrainPost: %s\n" % e)

Parameters

Body parameters
Name Description
body

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


updateUpdatePost

Downloads (if not already in cache) and apply an update.


/update/update

Usage and SDK Samples

curl -X POST -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/update/update"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.UpdateApi;

import java.io.File;
import java.util.*;

public class UpdateApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        UpdateApi apiInstance = new UpdateApi();
        Update_update_0 body = ; // Update_update_0 | 
        try {
            apiInstance.updateUpdatePost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling UpdateApi#updateUpdatePost");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::UpdateApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::UpdateApi->new();
my $body = WWW::SwaggerClient::Object::Update_update_0->new(); # Update_update_0 | 

eval { 
    $api_instance->updateUpdatePost(body => $body);
};
if ($@) {
    warn "Exception when calling UpdateApi->updateUpdatePost: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.UpdateApi()
body =  # Update_update_0 |  (optional)

try: 
    api_instance.update_update_post(body=body)
except ApiException as e:
    print("Exception when calling UpdateApi->updateUpdatePost: %s\n" % e)

Parameters

Body parameters
Name Description
body

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


Ups

upsDriverChoicesGet

Returns choices of UPS drivers supported by the system.


/ups/driver_choices

Usage and SDK Samples

curl -X GET -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/ups/driver_choices"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.UpsApi;

import java.io.File;
import java.util.*;

public class UpsApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        UpsApi apiInstance = new UpsApi();
        try {
            apiInstance.upsDriverChoicesGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling UpsApi#upsDriverChoicesGet");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::UpsApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::UpsApi->new();

eval { 
    $api_instance->upsDriverChoicesGet();
};
if ($@) {
    warn "Exception when calling UpsApi->upsDriverChoicesGet: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.UpsApi()

try: 
    api_instance.ups_driver_choices_get()
except ApiException as e:
    print("Exception when calling UpsApi->upsDriverChoicesGet: %s\n" % e)

Parameters

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


upsGet


/ups

Usage and SDK Samples

curl -X GET -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/ups"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.UpsApi;

import java.io.File;
import java.util.*;

public class UpsApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        UpsApi apiInstance = new UpsApi();
        try {
            apiInstance.upsGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling UpsApi#upsGet");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::UpsApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::UpsApi->new();

eval { 
    $api_instance->upsGet();
};
if ($@) {
    warn "Exception when calling UpsApi->upsGet: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.UpsApi()

try: 
    api_instance.ups_get()
except ApiException as e:
    print("Exception when calling UpsApi->upsGet: %s\n" % e)

Parameters

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


upsPortChoicesGet


/ups/port_choices

Usage and SDK Samples

curl -X GET -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/ups/port_choices"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.UpsApi;

import java.io.File;
import java.util.*;

public class UpsApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        UpsApi apiInstance = new UpsApi();
        try {
            apiInstance.upsPortChoicesGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling UpsApi#upsPortChoicesGet");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::UpsApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::UpsApi->new();

eval { 
    $api_instance->upsPortChoicesGet();
};
if ($@) {
    warn "Exception when calling UpsApi->upsPortChoicesGet: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.UpsApi()

try: 
    api_instance.ups_port_choices_get()
except ApiException as e:
    print("Exception when calling UpsApi->upsPortChoicesGet: %s\n" % e)

Parameters

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


upsPut

Update UPS Service Configuration. `emailnotify` when enabled, sends out notifications of different UPS events via email. `powerdown` when enabled, sets UPS to power off after shutting down the system. `nocommwarntime` is a value in seconds which makes UPS Service wait the specified seconds before alerting that the Service cannot reach configured UPS. `shutdowntimer` is a value in seconds which tells the Service to wait specified seconds for the UPS before initiating a shutdown. This only applies when `shutdown` is set to "BATT". `shutdowncmd` is the command which is executed to initiate a shutdown. It defaults to "poweroff". `toemail` is a list of valid email id's on which notification emails are sent.


/ups

Usage and SDK Samples

curl -X PUT -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/ups"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.UpsApi;

import java.io.File;
import java.util.*;

public class UpsApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        UpsApi apiInstance = new UpsApi();
        Ups_update_0 body = ; // Ups_update_0 | 
        try {
            apiInstance.upsPut(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling UpsApi#upsPut");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::UpsApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::UpsApi->new();
my $body = WWW::SwaggerClient::Object::Ups_update_0->new(); # Ups_update_0 | 

eval { 
    $api_instance->upsPut(body => $body);
};
if ($@) {
    warn "Exception when calling UpsApi->upsPut: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.UpsApi()
body =  # Ups_update_0 |  (optional)

try: 
    api_instance.ups_put(body=body)
except ApiException as e:
    print("Exception when calling UpsApi->upsPut: %s\n" % e)

Parameters

Body parameters
Name Description
body

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


User

userGet

Query users with `query-filters` and `query-options`. As a performance optimization, only local users will be queried by default. Users from directory services such as NIS, LDAP, or Active Directory will be included in query results if the option `{'extra': {'search_dscache': True}}` is specified.


/user

Usage and SDK Samples

curl -X GET -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/user?limit=&offset=&count=&sort="
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.UserApi;

import java.io.File;
import java.util.*;

public class UserApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        UserApi apiInstance = new UserApi();
        Integer limit = 56; // Integer | 
        Integer offset = 56; // Integer | 
        Boolean count = true; // Boolean | 
        String sort = sort_example; // String | 
        try {
            apiInstance.userGet(limit, offset, count, sort);
        } catch (ApiException e) {
            System.err.println("Exception when calling UserApi#userGet");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::UserApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::UserApi->new();
my $limit = 56; # Integer | 
my $offset = 56; # Integer | 
my $count = true; # Boolean | 
my $sort = sort_example; # String | 

eval { 
    $api_instance->userGet(limit => $limit, offset => $offset, count => $count, sort => $sort);
};
if ($@) {
    warn "Exception when calling UserApi->userGet: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.UserApi()
limit = 56 # Integer |  (optional)
offset = 56 # Integer |  (optional)
count = true # Boolean |  (optional)
sort = sort_example # String |  (optional)

try: 
    api_instance.user_get(limit=limit, offset=offset, count=count, sort=sort)
except ApiException as e:
    print("Exception when calling UserApi->userGet: %s\n" % e)

Parameters

Query parameters
Name Description
limit
Integer
offset
Integer
count
Boolean
sort
String

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


userGetNextUidGet

Get the next available/free uid.


/user/get_next_uid

Usage and SDK Samples

curl -X GET -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/user/get_next_uid"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.UserApi;

import java.io.File;
import java.util.*;

public class UserApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        UserApi apiInstance = new UserApi();
        try {
            apiInstance.userGetNextUidGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling UserApi#userGetNextUidGet");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::UserApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::UserApi->new();

eval { 
    $api_instance->userGetNextUidGet();
};
if ($@) {
    warn "Exception when calling UserApi->userGetNextUidGet: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.UserApi()

try: 
    api_instance.user_get_next_uid_get()
except ApiException as e:
    print("Exception when calling UserApi->userGetNextUidGet: %s\n" % e)

Parameters

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


userGetUserObjPost

Returns dictionary containing information from struct passwd for the user specified by either the username or uid. Bypasses user cache.


/user/get_user_obj

Usage and SDK Samples

curl -X POST -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/user/get_user_obj"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.UserApi;

import java.io.File;
import java.util.*;

public class UserApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        UserApi apiInstance = new UserApi();
        User_get_user_obj_0 body = ; // User_get_user_obj_0 | 
        try {
            apiInstance.userGetUserObjPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling UserApi#userGetUserObjPost");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::UserApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::UserApi->new();
my $body = WWW::SwaggerClient::Object::User_get_user_obj_0->new(); # User_get_user_obj_0 | 

eval { 
    $api_instance->userGetUserObjPost(body => $body);
};
if ($@) {
    warn "Exception when calling UserApi->userGetUserObjPost: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.UserApi()
body =  # User_get_user_obj_0 |  (optional)

try: 
    api_instance.user_get_user_obj_post(body=body)
except ApiException as e:
    print("Exception when calling UserApi->userGetUserObjPost: %s\n" % e)

Parameters

Body parameters
Name Description
body

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


userHasRootPasswordGet

Return whether the root user has a valid password set. This is used when the system is installed without a password and must be set on first use/login.


/user/has_root_password

Usage and SDK Samples

curl -X GET -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/user/has_root_password"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.UserApi;

import java.io.File;
import java.util.*;

public class UserApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        UserApi apiInstance = new UserApi();
        try {
            apiInstance.userHasRootPasswordGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling UserApi#userHasRootPasswordGet");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::UserApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::UserApi->new();

eval { 
    $api_instance->userHasRootPasswordGet();
};
if ($@) {
    warn "Exception when calling UserApi->userHasRootPasswordGet: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.UserApi()

try: 
    api_instance.user_has_root_password_get()
except ApiException as e:
    print("Exception when calling UserApi->userHasRootPasswordGet: %s\n" % e)

Parameters

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


userIdIdDelete

Delete user `id`. The `delete_group` option deletes the user primary group if it is not being used by any other user.


/user/id/{id}

Usage and SDK Samples

curl -X DELETE -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/user/id/{id}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.UserApi;

import java.io.File;
import java.util.*;

public class UserApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        UserApi apiInstance = new UserApi();
        Integer id = 56; // Integer | 
        User_delete_1 body = ; // User_delete_1 | 
        try {
            apiInstance.userIdIdDelete(id, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling UserApi#userIdIdDelete");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::UserApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::UserApi->new();
my $id = 56; # Integer | 
my $body = WWW::SwaggerClient::Object::User_delete_1->new(); # User_delete_1 | 

eval { 
    $api_instance->userIdIdDelete(id => $id, body => $body);
};
if ($@) {
    warn "Exception when calling UserApi->userIdIdDelete: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.UserApi()
id = 56 # Integer | 
body =  # User_delete_1 |  (optional)

try: 
    api_instance.user_id_id_delete(id, body=body)
except ApiException as e:
    print("Exception when calling UserApi->userIdIdDelete: %s\n" % e)

Parameters

Path parameters
Name Description
id*
Integer
Required
Body parameters
Name Description
body

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


userIdIdGet

Query users with `query-filters` and `query-options`. As a performance optimization, only local users will be queried by default. Users from directory services such as NIS, LDAP, or Active Directory will be included in query results if the option `{'extra': {'search_dscache': True}}` is specified.


/user/id/{id}

Usage and SDK Samples

curl -X GET -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/user/id/{id}?limit=&offset=&count=&sort="
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.UserApi;

import java.io.File;
import java.util.*;

public class UserApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        UserApi apiInstance = new UserApi();
        array[null] id = ; // array[null] | 
        Integer limit = 56; // Integer | 
        Integer offset = 56; // Integer | 
        Boolean count = true; // Boolean | 
        String sort = sort_example; // String | 
        try {
            apiInstance.userIdIdGet(id, limit, offset, count, sort);
        } catch (ApiException e) {
            System.err.println("Exception when calling UserApi#userIdIdGet");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::UserApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::UserApi->new();
my $id = []; # array[null] | 
my $limit = 56; # Integer | 
my $offset = 56; # Integer | 
my $count = true; # Boolean | 
my $sort = sort_example; # String | 

eval { 
    $api_instance->userIdIdGet(id => $id, limit => $limit, offset => $offset, count => $count, sort => $sort);
};
if ($@) {
    warn "Exception when calling UserApi->userIdIdGet: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.UserApi()
id =  # array[null] | 
limit = 56 # Integer |  (optional)
offset = 56 # Integer |  (optional)
count = true # Boolean |  (optional)
sort = sort_example # String |  (optional)

try: 
    api_instance.user_id_id_get(id, limit=limit, offset=offset, count=count, sort=sort)
except ApiException as e:
    print("Exception when calling UserApi->userIdIdGet: %s\n" % e)

Parameters

Path parameters
Name Description
id*
array[null]
Required
Query parameters
Name Description
limit
Integer
offset
Integer
count
Boolean
sort
String

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


userIdIdPopAttributePost

Remove user general purpose `attributes` dictionary `key`.


/user/id/{id}/pop_attribute

Usage and SDK Samples

curl -X POST -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/user/id/{id}/pop_attribute"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.UserApi;

import java.io.File;
import java.util.*;

public class UserApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        UserApi apiInstance = new UserApi();
        Integer id = 56; // Integer | 
        String body = ; // String | 
        try {
            apiInstance.userIdIdPopAttributePost(id, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling UserApi#userIdIdPopAttributePost");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::UserApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::UserApi->new();
my $id = 56; # Integer | 
my $body = WWW::SwaggerClient::Object::String->new(); # String | 

eval { 
    $api_instance->userIdIdPopAttributePost(id => $id, body => $body);
};
if ($@) {
    warn "Exception when calling UserApi->userIdIdPopAttributePost: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.UserApi()
id = 56 # Integer | 
body =  # String |  (optional)

try: 
    api_instance.user_id_id_pop_attribute_post(id, body=body)
except ApiException as e:
    print("Exception when calling UserApi->userIdIdPopAttributePost: %s\n" % e)

Parameters

Path parameters
Name Description
id*
Integer
Required
Body parameters
Name Description
body

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


userIdIdPut

Update attributes of an existing user.


/user/id/{id}

Usage and SDK Samples

curl -X PUT -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/user/id/{id}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.UserApi;

import java.io.File;
import java.util.*;

public class UserApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        UserApi apiInstance = new UserApi();
        Integer id = 56; // Integer | 
        User_update_1 body = ; // User_update_1 | 
        try {
            apiInstance.userIdIdPut(id, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling UserApi#userIdIdPut");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::UserApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::UserApi->new();
my $id = 56; # Integer | 
my $body = WWW::SwaggerClient::Object::User_update_1->new(); # User_update_1 | 

eval { 
    $api_instance->userIdIdPut(id => $id, body => $body);
};
if ($@) {
    warn "Exception when calling UserApi->userIdIdPut: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.UserApi()
id = 56 # Integer | 
body =  # User_update_1 |  (optional)

try: 
    api_instance.user_id_id_put(id, body=body)
except ApiException as e:
    print("Exception when calling UserApi->userIdIdPut: %s\n" % e)

Parameters

Path parameters
Name Description
id*
Integer
Required
Body parameters
Name Description
body

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


userIdIdSetAttributePost

Set user general purpose `attributes` dictionary `key` to `value`. e.g. Setting key="foo" value="var" will result in {"attributes": {"foo": "bar"}}


/user/id/{id}/set_attribute

Usage and SDK Samples

curl -X POST -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/user/id/{id}/set_attribute"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.UserApi;

import java.io.File;
import java.util.*;

public class UserApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        UserApi apiInstance = new UserApi();
        Integer id = 56; // Integer | 
        User_set_attribute body = ; // User_set_attribute | 
        try {
            apiInstance.userIdIdSetAttributePost(id, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling UserApi#userIdIdSetAttributePost");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::UserApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::UserApi->new();
my $id = 56; # Integer | 
my $body = WWW::SwaggerClient::Object::User_set_attribute->new(); # User_set_attribute | 

eval { 
    $api_instance->userIdIdSetAttributePost(id => $id, body => $body);
};
if ($@) {
    warn "Exception when calling UserApi->userIdIdSetAttributePost: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.UserApi()
id = 56 # Integer | 
body =  # User_set_attribute |  (optional)

try: 
    api_instance.user_id_id_set_attribute_post(id, body=body)
except ApiException as e:
    print("Exception when calling UserApi->userIdIdSetAttributePost: %s\n" % e)

Parameters

Path parameters
Name Description
id*
Integer
Required
Body parameters
Name Description
body

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


userPost

Create a new user. If `uid` is not provided it is automatically filled with the next one available. `group` is required if `group_create` is false. `password` is required if `password_disabled` is false. Available choices for `shell` can be retrieved with `user.shell_choices`. `attributes` is a general-purpose object for storing arbitrary user information. `smb` specifies whether the user should be allowed access to SMB shares. User willl also automatically be added to the `builtin_users` group.


/user

Usage and SDK Samples

curl -X POST -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/user"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.UserApi;

import java.io.File;
import java.util.*;

public class UserApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        UserApi apiInstance = new UserApi();
        User_create_0 body = ; // User_create_0 | 
        try {
            apiInstance.userPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling UserApi#userPost");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::UserApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::UserApi->new();
my $body = WWW::SwaggerClient::Object::User_create_0->new(); # User_create_0 | 

eval { 
    $api_instance->userPost(body => $body);
};
if ($@) {
    warn "Exception when calling UserApi->userPost: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.UserApi()
body =  # User_create_0 |  (optional)

try: 
    api_instance.user_post(body=body)
except ApiException as e:
    print("Exception when calling UserApi->userPost: %s\n" % e)

Parameters

Body parameters
Name Description
body

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


userShellChoicesPost

Return the available shell choices to be used in `user.create` and `user.update`. If `user_id` is provided, shell choices are filtered to ensure the user can access the shell choices provided.


/user/shell_choices

Usage and SDK Samples

curl -X POST -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/user/shell_choices"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.UserApi;

import java.io.File;
import java.util.*;

public class UserApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        UserApi apiInstance = new UserApi();
        Integer body = ; // Integer | 
        try {
            apiInstance.userShellChoicesPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling UserApi#userShellChoicesPost");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::UserApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::UserApi->new();
my $body = WWW::SwaggerClient::Object::Integer->new(); # Integer | 

eval { 
    $api_instance->userShellChoicesPost(body => $body);
};
if ($@) {
    warn "Exception when calling UserApi->userShellChoicesPost: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.UserApi()
body =  # Integer |  (optional)

try: 
    api_instance.user_shell_choices_post(body=body)
except ApiException as e:
    print("Exception when calling UserApi->userShellChoicesPost: %s\n" % e)

Parameters

Body parameters
Name Description
body

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


Vm

vmFlagsGet

Returns a dictionary with CPU flags for bhyve.


/vm/flags

Usage and SDK Samples

curl -X GET -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/vm/flags"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.VmApi;

import java.io.File;
import java.util.*;

public class VmApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        VmApi apiInstance = new VmApi();
        try {
            apiInstance.vmFlagsGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling VmApi#vmFlagsGet");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::VmApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::VmApi->new();

eval { 
    $api_instance->vmFlagsGet();
};
if ($@) {
    warn "Exception when calling VmApi->vmFlagsGet: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.VmApi()

try: 
    api_instance.vm_flags_get()
except ApiException as e:
    print("Exception when calling VmApi->vmFlagsGet: %s\n" % e)

Parameters

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


vmGet


/vm

Usage and SDK Samples

curl -X GET -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/vm?limit=&offset=&count=&sort="
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.VmApi;

import java.io.File;
import java.util.*;

public class VmApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        VmApi apiInstance = new VmApi();
        Integer limit = 56; // Integer | 
        Integer offset = 56; // Integer | 
        Boolean count = true; // Boolean | 
        String sort = sort_example; // String | 
        try {
            apiInstance.vmGet(limit, offset, count, sort);
        } catch (ApiException e) {
            System.err.println("Exception when calling VmApi#vmGet");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::VmApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::VmApi->new();
my $limit = 56; # Integer | 
my $offset = 56; # Integer | 
my $count = true; # Boolean | 
my $sort = sort_example; # String | 

eval { 
    $api_instance->vmGet(limit => $limit, offset => $offset, count => $count, sort => $sort);
};
if ($@) {
    warn "Exception when calling VmApi->vmGet: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.VmApi()
limit = 56 # Integer |  (optional)
offset = 56 # Integer |  (optional)
count = true # Boolean |  (optional)
sort = sort_example # String |  (optional)

try: 
    api_instance.vm_get(limit=limit, offset=offset, count=count, sort=sort)
except ApiException as e:
    print("Exception when calling VmApi->vmGet: %s\n" % e)

Parameters

Query parameters
Name Description
limit
Integer
offset
Integer
count
Boolean
sort
String

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


vmGetAttachedIfacePost

Get the attached physical interfaces from a given guest. Returns: list: will return a list with all attached phisycal interfaces or otherwise False.


/vm/get_attached_iface

Usage and SDK Samples

curl -X POST -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/vm/get_attached_iface"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.VmApi;

import java.io.File;
import java.util.*;

public class VmApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        VmApi apiInstance = new VmApi();
        Integer body = ; // Integer | 
        try {
            apiInstance.vmGetAttachedIfacePost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling VmApi#vmGetAttachedIfacePost");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::VmApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::VmApi->new();
my $body = WWW::SwaggerClient::Object::Integer->new(); # Integer | 

eval { 
    $api_instance->vmGetAttachedIfacePost(body => $body);
};
if ($@) {
    warn "Exception when calling VmApi->vmGetAttachedIfacePost: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.VmApi()
body =  # Integer |  (optional)

try: 
    api_instance.vm_get_attached_iface_post(body=body)
except ApiException as e:
    print("Exception when calling VmApi->vmGetAttachedIfacePost: %s\n" % e)

Parameters

Body parameters
Name Description
body

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


vmGetAvailableMemoryPost

Get the current maximum amount of available memory to be allocated for VMs. If `overcommit` is true only the current used memory of running VMs will be accounted for. If false all memory (including unused) of runnings VMs will be accounted for. This will include memory shrinking ZFS ARC to the minimum. Memory is of course a very "volatile" resource, values may change abruptly between a second but I deem it good enough to give the user a clue about how much memory is available at the current moment and if a VM should be allowed to be launched.


/vm/get_available_memory

Usage and SDK Samples

curl -X POST -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/vm/get_available_memory"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.VmApi;

import java.io.File;
import java.util.*;

public class VmApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        VmApi apiInstance = new VmApi();
        Boolean body = ; // Boolean | 
        try {
            apiInstance.vmGetAvailableMemoryPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling VmApi#vmGetAvailableMemoryPost");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::VmApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::VmApi->new();
my $body = WWW::SwaggerClient::Object::Boolean->new(); # Boolean | 

eval { 
    $api_instance->vmGetAvailableMemoryPost(body => $body);
};
if ($@) {
    warn "Exception when calling VmApi->vmGetAvailableMemoryPost: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.VmApi()
body =  # Boolean |  (optional)

try: 
    api_instance.vm_get_available_memory_post(body=body)
except ApiException as e:
    print("Exception when calling VmApi->vmGetAvailableMemoryPost: %s\n" % e)

Parameters

Body parameters
Name Description
body

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


vmGetConsolePost

Get the console device from a given guest. Returns: str: with the device path or False.


/vm/get_console

Usage and SDK Samples

curl -X POST -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/vm/get_console"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.VmApi;

import java.io.File;
import java.util.*;

public class VmApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        VmApi apiInstance = new VmApi();
        Integer body = ; // Integer | 
        try {
            apiInstance.vmGetConsolePost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling VmApi#vmGetConsolePost");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::VmApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::VmApi->new();
my $body = WWW::SwaggerClient::Object::Integer->new(); # Integer | 

eval { 
    $api_instance->vmGetConsolePost(body => $body);
};
if ($@) {
    warn "Exception when calling VmApi->vmGetConsolePost: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.VmApi()
body =  # Integer |  (optional)

try: 
    api_instance.vm_get_console_post(body=body)
except ApiException as e:
    print("Exception when calling VmApi->vmGetConsolePost: %s\n" % e)

Parameters

Body parameters
Name Description
body

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


vmGetVmemoryInUseGet

The total amount of virtual memory in MB used by guests Returns a dict with the following information: RNP - Running but not provisioned PRD - Provisioned but not running RPRD - Running and provisioned


/vm/get_vmemory_in_use

Usage and SDK Samples

curl -X GET -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/vm/get_vmemory_in_use"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.VmApi;

import java.io.File;
import java.util.*;

public class VmApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        VmApi apiInstance = new VmApi();
        try {
            apiInstance.vmGetVmemoryInUseGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling VmApi#vmGetVmemoryInUseGet");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::VmApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::VmApi->new();

eval { 
    $api_instance->vmGetVmemoryInUseGet();
};
if ($@) {
    warn "Exception when calling VmApi->vmGetVmemoryInUseGet: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.VmApi()

try: 
    api_instance.vm_get_vmemory_in_use_get()
except ApiException as e:
    print("Exception when calling VmApi->vmGetVmemoryInUseGet: %s\n" % e)

Parameters

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


vmGetVncIpv4Get

Get all available IPv4 address in the system. Returns: list: will return a list of available IPv4 address.


/vm/get_vnc_ipv4

Usage and SDK Samples

curl -X GET -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/vm/get_vnc_ipv4"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.VmApi;

import java.io.File;
import java.util.*;

public class VmApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        VmApi apiInstance = new VmApi();
        try {
            apiInstance.vmGetVncIpv4Get();
        } catch (ApiException e) {
            System.err.println("Exception when calling VmApi#vmGetVncIpv4Get");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::VmApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::VmApi->new();

eval { 
    $api_instance->vmGetVncIpv4Get();
};
if ($@) {
    warn "Exception when calling VmApi->vmGetVncIpv4Get: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.VmApi()

try: 
    api_instance.vm_get_vnc_ipv4_get()
except ApiException as e:
    print("Exception when calling VmApi->vmGetVncIpv4Get: %s\n" % e)

Parameters

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


vmGetVncPost

Get the vnc devices from a given guest. Returns: list(dict): with all attributes of the vnc device or an empty list.


/vm/get_vnc

Usage and SDK Samples

curl -X POST -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/vm/get_vnc"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.VmApi;

import java.io.File;
import java.util.*;

public class VmApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        VmApi apiInstance = new VmApi();
        Integer body = ; // Integer | 
        try {
            apiInstance.vmGetVncPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling VmApi#vmGetVncPost");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::VmApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::VmApi->new();
my $body = WWW::SwaggerClient::Object::Integer->new(); # Integer | 

eval { 
    $api_instance->vmGetVncPost(body => $body);
};
if ($@) {
    warn "Exception when calling VmApi->vmGetVncPost: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.VmApi()
body =  # Integer |  (optional)

try: 
    api_instance.vm_get_vnc_post(body=body)
except ApiException as e:
    print("Exception when calling VmApi->vmGetVncPost: %s\n" % e)

Parameters

Body parameters
Name Description
body

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


vmIdIdClonePost

Clone the VM `id`. `name` is an optional parameter for the cloned VM. If not provided it will append the next number available to the VM name.


/vm/id/{id}/clone

Usage and SDK Samples

curl -X POST -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/vm/id/{id}/clone"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.VmApi;

import java.io.File;
import java.util.*;

public class VmApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        VmApi apiInstance = new VmApi();
        Integer id = 56; // Integer | 
        String body = ; // String | 
        try {
            apiInstance.vmIdIdClonePost(id, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling VmApi#vmIdIdClonePost");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::VmApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::VmApi->new();
my $id = 56; # Integer | 
my $body = WWW::SwaggerClient::Object::String->new(); # String | 

eval { 
    $api_instance->vmIdIdClonePost(id => $id, body => $body);
};
if ($@) {
    warn "Exception when calling VmApi->vmIdIdClonePost: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.VmApi()
id = 56 # Integer | 
body =  # String |  (optional)

try: 
    api_instance.vm_id_id_clone_post(id, body=body)
except ApiException as e:
    print("Exception when calling VmApi->vmIdIdClonePost: %s\n" % e)

Parameters

Path parameters
Name Description
id*
Integer
Required
Body parameters
Name Description
body

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


vmIdIdDelete

Delete a VM.


/vm/id/{id}

Usage and SDK Samples

curl -X DELETE -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/vm/id/{id}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.VmApi;

import java.io.File;
import java.util.*;

public class VmApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        VmApi apiInstance = new VmApi();
        Integer id = 56; // Integer | 
        Vm_delete_1 body = ; // Vm_delete_1 | 
        try {
            apiInstance.vmIdIdDelete(id, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling VmApi#vmIdIdDelete");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::VmApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::VmApi->new();
my $id = 56; # Integer | 
my $body = WWW::SwaggerClient::Object::Vm_delete_1->new(); # Vm_delete_1 | 

eval { 
    $api_instance->vmIdIdDelete(id => $id, body => $body);
};
if ($@) {
    warn "Exception when calling VmApi->vmIdIdDelete: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.VmApi()
id = 56 # Integer | 
body =  # Vm_delete_1 |  (optional)

try: 
    api_instance.vm_id_id_delete(id, body=body)
except ApiException as e:
    print("Exception when calling VmApi->vmIdIdDelete: %s\n" % e)

Parameters

Path parameters
Name Description
id*
Integer
Required
Body parameters
Name Description
body

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


vmIdIdGet


/vm/id/{id}

Usage and SDK Samples

curl -X GET -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/vm/id/{id}?limit=&offset=&count=&sort="
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.VmApi;

import java.io.File;
import java.util.*;

public class VmApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        VmApi apiInstance = new VmApi();
        array[null] id = ; // array[null] | 
        Integer limit = 56; // Integer | 
        Integer offset = 56; // Integer | 
        Boolean count = true; // Boolean | 
        String sort = sort_example; // String | 
        try {
            apiInstance.vmIdIdGet(id, limit, offset, count, sort);
        } catch (ApiException e) {
            System.err.println("Exception when calling VmApi#vmIdIdGet");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::VmApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::VmApi->new();
my $id = []; # array[null] | 
my $limit = 56; # Integer | 
my $offset = 56; # Integer | 
my $count = true; # Boolean | 
my $sort = sort_example; # String | 

eval { 
    $api_instance->vmIdIdGet(id => $id, limit => $limit, offset => $offset, count => $count, sort => $sort);
};
if ($@) {
    warn "Exception when calling VmApi->vmIdIdGet: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.VmApi()
id =  # array[null] | 
limit = 56 # Integer |  (optional)
offset = 56 # Integer |  (optional)
count = true # Boolean |  (optional)
sort = sort_example # String |  (optional)

try: 
    api_instance.vm_id_id_get(id, limit=limit, offset=offset, count=count, sort=sort)
except ApiException as e:
    print("Exception when calling VmApi->vmIdIdGet: %s\n" % e)

Parameters

Path parameters
Name Description
id*
array[null]
Required
Query parameters
Name Description
limit
Integer
offset
Integer
count
Boolean
sort
String

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


vmIdIdPoweroffPost


/vm/id/{id}/poweroff

Usage and SDK Samples

curl -X POST -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/vm/id/{id}/poweroff"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.VmApi;

import java.io.File;
import java.util.*;

public class VmApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        VmApi apiInstance = new VmApi();
        Integer id = 56; // Integer | 
        Vm_poweroff body = ; // Vm_poweroff | 
        try {
            apiInstance.vmIdIdPoweroffPost(id, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling VmApi#vmIdIdPoweroffPost");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::VmApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::VmApi->new();
my $id = 56; # Integer | 
my $body = WWW::SwaggerClient::Object::Vm_poweroff->new(); # Vm_poweroff | 

eval { 
    $api_instance->vmIdIdPoweroffPost(id => $id, body => $body);
};
if ($@) {
    warn "Exception when calling VmApi->vmIdIdPoweroffPost: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.VmApi()
id = 56 # Integer | 
body =  # Vm_poweroff |  (optional)

try: 
    api_instance.vm_id_id_poweroff_post(id, body=body)
except ApiException as e:
    print("Exception when calling VmApi->vmIdIdPoweroffPost: %s\n" % e)

Parameters

Path parameters
Name Description
id*
Integer
Required
Body parameters
Name Description
body

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


vmIdIdPut

Update all information of a specific VM. `devices` is a list of virtualized hardware to attach to the virtual machine. If `devices` is not present, no change is made to devices. If either the device list order or data stored by the device changes when the attribute is passed, these actions are taken: 1) If there is no device in the `devices` list which was previously attached to the VM, that device is removed from the virtual machine. 2) Devices are updated in the `devices` list when they contain a valid `id` attribute that corresponds to an existing device. 3) Devices that do not have an `id` attribute are created and attached to `id` VM.


/vm/id/{id}

Usage and SDK Samples

curl -X PUT -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/vm/id/{id}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.VmApi;

import java.io.File;
import java.util.*;

public class VmApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        VmApi apiInstance = new VmApi();
        Integer id = 56; // Integer | 
        Vm_update_1 body = ; // Vm_update_1 | 
        try {
            apiInstance.vmIdIdPut(id, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling VmApi#vmIdIdPut");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::VmApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::VmApi->new();
my $id = 56; # Integer | 
my $body = WWW::SwaggerClient::Object::Vm_update_1->new(); # Vm_update_1 | 

eval { 
    $api_instance->vmIdIdPut(id => $id, body => $body);
};
if ($@) {
    warn "Exception when calling VmApi->vmIdIdPut: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.VmApi()
id = 56 # Integer | 
body =  # Vm_update_1 |  (optional)

try: 
    api_instance.vm_id_id_put(id, body=body)
except ApiException as e:
    print("Exception when calling VmApi->vmIdIdPut: %s\n" % e)

Parameters

Path parameters
Name Description
id*
Integer
Required
Body parameters
Name Description
body

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


vmIdIdRestartPost

Restart a VM.


/vm/id/{id}/restart

Usage and SDK Samples

curl -X POST -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/vm/id/{id}/restart"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.VmApi;

import java.io.File;
import java.util.*;

public class VmApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        VmApi apiInstance = new VmApi();
        Integer id = 56; // Integer | 
        Vm_restart body = ; // Vm_restart | 
        try {
            apiInstance.vmIdIdRestartPost(id, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling VmApi#vmIdIdRestartPost");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::VmApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::VmApi->new();
my $id = 56; # Integer | 
my $body = WWW::SwaggerClient::Object::Vm_restart->new(); # Vm_restart | 

eval { 
    $api_instance->vmIdIdRestartPost(id => $id, body => $body);
};
if ($@) {
    warn "Exception when calling VmApi->vmIdIdRestartPost: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.VmApi()
id = 56 # Integer | 
body =  # Vm_restart |  (optional)

try: 
    api_instance.vm_id_id_restart_post(id, body=body)
except ApiException as e:
    print("Exception when calling VmApi->vmIdIdRestartPost: %s\n" % e)

Parameters

Path parameters
Name Description
id*
Integer
Required
Body parameters
Name Description
body

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


vmIdIdStartPost

Start a VM. options.overcommit defaults to false, meaning VMs are not allowed to start if there is not enough available memory to hold all configured VMs. If true, VM starts even if there is not enough memory for all configured VMs. Error codes: ENOMEM(12): not enough free memory to run the VM without overcommit


/vm/id/{id}/start

Usage and SDK Samples

curl -X POST -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/vm/id/{id}/start"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.VmApi;

import java.io.File;
import java.util.*;

public class VmApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        VmApi apiInstance = new VmApi();
        Integer id = 56; // Integer | 
        Vm_start_1 body = ; // Vm_start_1 | 
        try {
            apiInstance.vmIdIdStartPost(id, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling VmApi#vmIdIdStartPost");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::VmApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::VmApi->new();
my $id = 56; # Integer | 
my $body = WWW::SwaggerClient::Object::Vm_start_1->new(); # Vm_start_1 | 

eval { 
    $api_instance->vmIdIdStartPost(id => $id, body => $body);
};
if ($@) {
    warn "Exception when calling VmApi->vmIdIdStartPost: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.VmApi()
id = 56 # Integer | 
body =  # Vm_start_1 |  (optional)

try: 
    api_instance.vm_id_id_start_post(id, body=body)
except ApiException as e:
    print("Exception when calling VmApi->vmIdIdStartPost: %s\n" % e)

Parameters

Path parameters
Name Description
id*
Integer
Required
Body parameters
Name Description
body

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


vmIdIdStatusPost

Get the status of a VM. Returns a dict: - state, RUNNING or STOPPED - pid, process id if RUNNING


/vm/id/{id}/status

Usage and SDK Samples

curl -X POST -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/vm/id/{id}/status"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.VmApi;

import java.io.File;
import java.util.*;

public class VmApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        VmApi apiInstance = new VmApi();
        Integer id = 56; // Integer | 
        Vm_status body = ; // Vm_status | 
        try {
            apiInstance.vmIdIdStatusPost(id, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling VmApi#vmIdIdStatusPost");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::VmApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::VmApi->new();
my $id = 56; # Integer | 
my $body = WWW::SwaggerClient::Object::Vm_status->new(); # Vm_status | 

eval { 
    $api_instance->vmIdIdStatusPost(id => $id, body => $body);
};
if ($@) {
    warn "Exception when calling VmApi->vmIdIdStatusPost: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.VmApi()
id = 56 # Integer | 
body =  # Vm_status |  (optional)

try: 
    api_instance.vm_id_id_status_post(id, body=body)
except ApiException as e:
    print("Exception when calling VmApi->vmIdIdStatusPost: %s\n" % e)

Parameters

Path parameters
Name Description
id*
Integer
Required
Body parameters
Name Description
body

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


vmIdIdStopPost

Stops a VM. For unresponsive guests who have exceeded the `shutdown_timeout` defined by the user and have become unresponsive, they required to be powered down using `vm.poweroff`. `vm.stop` is only going to send a shutdown signal to the guest and wait the desired `shutdown_timeout` value before tearing down guest vmemory. `force_after_timeout` when supplied, it will initiate poweroff for the VM forcing it to exit if it has not already stopped within the specified `shutdown_timeout`.


/vm/id/{id}/stop

Usage and SDK Samples

curl -X POST -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/vm/id/{id}/stop"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.VmApi;

import java.io.File;
import java.util.*;

public class VmApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        VmApi apiInstance = new VmApi();
        Integer id = 56; // Integer | 
        Vm_stop_1 body = ; // Vm_stop_1 | 
        try {
            apiInstance.vmIdIdStopPost(id, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling VmApi#vmIdIdStopPost");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::VmApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::VmApi->new();
my $id = 56; # Integer | 
my $body = WWW::SwaggerClient::Object::Vm_stop_1->new(); # Vm_stop_1 | 

eval { 
    $api_instance->vmIdIdStopPost(id => $id, body => $body);
};
if ($@) {
    warn "Exception when calling VmApi->vmIdIdStopPost: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.VmApi()
id = 56 # Integer | 
body =  # Vm_stop_1 |  (optional)

try: 
    api_instance.vm_id_id_stop_post(id, body=body)
except ApiException as e:
    print("Exception when calling VmApi->vmIdIdStopPost: %s\n" % e)

Parameters

Path parameters
Name Description
id*
Integer
Required
Body parameters
Name Description
body

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


vmIdentifyHypervisorGet

Identify Hypervisors that might work nested with bhyve. Returns: bool: True if compatible otherwise False.


/vm/identify_hypervisor

Usage and SDK Samples

curl -X GET -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/vm/identify_hypervisor"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.VmApi;

import java.io.File;
import java.util.*;

public class VmApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        VmApi apiInstance = new VmApi();
        try {
            apiInstance.vmIdentifyHypervisorGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling VmApi#vmIdentifyHypervisorGet");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::VmApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::VmApi->new();

eval { 
    $api_instance->vmIdentifyHypervisorGet();
};
if ($@) {
    warn "Exception when calling VmApi->vmIdentifyHypervisorGet: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.VmApi()

try: 
    api_instance.vm_identify_hypervisor_get()
except ApiException as e:
    print("Exception when calling VmApi->vmIdentifyHypervisorGet: %s\n" % e)

Parameters

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


vmPost

Create a Virtual Machine (VM). `grubconfig` may either be a path for the grub.cfg file or the actual content of the file to be used with GRUB bootloader. `devices` is a list of virtualized hardware to add to the newly created Virtual Machine. Failure to attach a device destroys the VM and any resources allocated by the VM devices. Maximum of 16 guest virtual CPUs are allowed. By default, every virtual CPU is configured as a separate package. Multiple cores can be configured per CPU by specifying `cores` attributes. `vcpus` specifies total number of CPU sockets. `cores` specifies number of cores per socket. `threads` specifies number of threads per core. `shutdown_timeout` indicates the time in seconds the system waits for the VM to cleanly shutdown. During system shutdown, if the VM hasn't exited after a hardware shutdown signal has been sent by the system within `shutdown_timeout` seconds, system initiates poweroff for the VM to stop it.


/vm

Usage and SDK Samples

curl -X POST -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/vm"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.VmApi;

import java.io.File;
import java.util.*;

public class VmApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        VmApi apiInstance = new VmApi();
        Vm_create_0 body = ; // Vm_create_0 | 
        try {
            apiInstance.vmPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling VmApi#vmPost");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::VmApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::VmApi->new();
my $body = WWW::SwaggerClient::Object::Vm_create_0->new(); # Vm_create_0 | 

eval { 
    $api_instance->vmPost(body => $body);
};
if ($@) {
    warn "Exception when calling VmApi->vmPost: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.VmApi()
body =  # Vm_create_0 |  (optional)

try: 
    api_instance.vm_post(body=body)
except ApiException as e:
    print("Exception when calling VmApi->vmPost: %s\n" % e)

Parameters

Body parameters
Name Description
body

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


vmRandomMacGet

Create a random mac address. Returns: str: with six groups of two hexadecimal digits


/vm/random_mac

Usage and SDK Samples

curl -X GET -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/vm/random_mac"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.VmApi;

import java.io.File;
import java.util.*;

public class VmApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        VmApi apiInstance = new VmApi();
        try {
            apiInstance.vmRandomMacGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling VmApi#vmRandomMacGet");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::VmApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::VmApi->new();

eval { 
    $api_instance->vmRandomMacGet();
};
if ($@) {
    warn "Exception when calling VmApi->vmRandomMacGet: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.VmApi()

try: 
    api_instance.vm_random_mac_get()
except ApiException as e:
    print("Exception when calling VmApi->vmRandomMacGet: %s\n" % e)

Parameters

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


vmVncPortWizardGet

It returns the next available VNC PORT and WEB VNC PORT. Returns a dict with two keys vnc_port and vnc_web.


/vm/vnc_port_wizard

Usage and SDK Samples

curl -X GET -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/vm/vnc_port_wizard"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.VmApi;

import java.io.File;
import java.util.*;

public class VmApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        VmApi apiInstance = new VmApi();
        try {
            apiInstance.vmVncPortWizardGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling VmApi#vmVncPortWizardGet");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::VmApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::VmApi->new();

eval { 
    $api_instance->vmVncPortWizardGet();
};
if ($@) {
    warn "Exception when calling VmApi->vmVncPortWizardGet: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.VmApi()

try: 
    api_instance.vm_vnc_port_wizard_get()
except ApiException as e:
    print("Exception when calling VmApi->vmVncPortWizardGet: %s\n" % e)

Parameters

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


VmDevice

vmDeviceGet


/vm/device

Usage and SDK Samples

curl -X GET -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/vm/device?limit=&offset=&count=&sort="
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.VmDeviceApi;

import java.io.File;
import java.util.*;

public class VmDeviceApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        VmDeviceApi apiInstance = new VmDeviceApi();
        Integer limit = 56; // Integer | 
        Integer offset = 56; // Integer | 
        Boolean count = true; // Boolean | 
        String sort = sort_example; // String | 
        try {
            apiInstance.vmDeviceGet(limit, offset, count, sort);
        } catch (ApiException e) {
            System.err.println("Exception when calling VmDeviceApi#vmDeviceGet");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::VmDeviceApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::VmDeviceApi->new();
my $limit = 56; # Integer | 
my $offset = 56; # Integer | 
my $count = true; # Boolean | 
my $sort = sort_example; # String | 

eval { 
    $api_instance->vmDeviceGet(limit => $limit, offset => $offset, count => $count, sort => $sort);
};
if ($@) {
    warn "Exception when calling VmDeviceApi->vmDeviceGet: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.VmDeviceApi()
limit = 56 # Integer |  (optional)
offset = 56 # Integer |  (optional)
count = true # Boolean |  (optional)
sort = sort_example # String |  (optional)

try: 
    api_instance.vm_device_get(limit=limit, offset=offset, count=count, sort=sort)
except ApiException as e:
    print("Exception when calling VmDeviceApi->vmDeviceGet: %s\n" % e)

Parameters

Query parameters
Name Description
limit
Integer
offset
Integer
count
Boolean
sort
String

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


vmDeviceIdIdDelete

Delete a VM device of `id`.


/vm/device/id/{id}

Usage and SDK Samples

curl -X DELETE -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/vm/device/id/{id}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.VmDeviceApi;

import java.io.File;
import java.util.*;

public class VmDeviceApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        VmDeviceApi apiInstance = new VmDeviceApi();
        Integer id = 56; // Integer | 
        Vm_device_delete_1 body = ; // Vm_device_delete_1 | 
        try {
            apiInstance.vmDeviceIdIdDelete(id, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling VmDeviceApi#vmDeviceIdIdDelete");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::VmDeviceApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::VmDeviceApi->new();
my $id = 56; # Integer | 
my $body = WWW::SwaggerClient::Object::Vm_device_delete_1->new(); # Vm_device_delete_1 | 

eval { 
    $api_instance->vmDeviceIdIdDelete(id => $id, body => $body);
};
if ($@) {
    warn "Exception when calling VmDeviceApi->vmDeviceIdIdDelete: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.VmDeviceApi()
id = 56 # Integer | 
body =  # Vm_device_delete_1 |  (optional)

try: 
    api_instance.vm_device_id_id_delete(id, body=body)
except ApiException as e:
    print("Exception when calling VmDeviceApi->vmDeviceIdIdDelete: %s\n" % e)

Parameters

Path parameters
Name Description
id*
Integer
Required
Body parameters
Name Description
body

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


vmDeviceIdIdGet


/vm/device/id/{id}

Usage and SDK Samples

curl -X GET -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/vm/device/id/{id}?limit=&offset=&count=&sort="
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.VmDeviceApi;

import java.io.File;
import java.util.*;

public class VmDeviceApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        VmDeviceApi apiInstance = new VmDeviceApi();
        array[null] id = ; // array[null] | 
        Integer limit = 56; // Integer | 
        Integer offset = 56; // Integer | 
        Boolean count = true; // Boolean | 
        String sort = sort_example; // String | 
        try {
            apiInstance.vmDeviceIdIdGet(id, limit, offset, count, sort);
        } catch (ApiException e) {
            System.err.println("Exception when calling VmDeviceApi#vmDeviceIdIdGet");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::VmDeviceApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::VmDeviceApi->new();
my $id = []; # array[null] | 
my $limit = 56; # Integer | 
my $offset = 56; # Integer | 
my $count = true; # Boolean | 
my $sort = sort_example; # String | 

eval { 
    $api_instance->vmDeviceIdIdGet(id => $id, limit => $limit, offset => $offset, count => $count, sort => $sort);
};
if ($@) {
    warn "Exception when calling VmDeviceApi->vmDeviceIdIdGet: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.VmDeviceApi()
id =  # array[null] | 
limit = 56 # Integer |  (optional)
offset = 56 # Integer |  (optional)
count = true # Boolean |  (optional)
sort = sort_example # String |  (optional)

try: 
    api_instance.vm_device_id_id_get(id, limit=limit, offset=offset, count=count, sort=sort)
except ApiException as e:
    print("Exception when calling VmDeviceApi->vmDeviceIdIdGet: %s\n" % e)

Parameters

Path parameters
Name Description
id*
array[null]
Required
Query parameters
Name Description
limit
Integer
offset
Integer
count
Boolean
sort
String

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


vmDeviceIdIdPut

Update a VM device of `id`. Pass `attributes.size` to resize a `dtype` `RAW` device. The raw file will be resized.


/vm/device/id/{id}

Usage and SDK Samples

curl -X PUT -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/vm/device/id/{id}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.VmDeviceApi;

import java.io.File;
import java.util.*;

public class VmDeviceApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        VmDeviceApi apiInstance = new VmDeviceApi();
        Integer id = 56; // Integer | 
        Vm_device_update_1 body = ; // Vm_device_update_1 | 
        try {
            apiInstance.vmDeviceIdIdPut(id, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling VmDeviceApi#vmDeviceIdIdPut");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::VmDeviceApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::VmDeviceApi->new();
my $id = 56; # Integer | 
my $body = WWW::SwaggerClient::Object::Vm_device_update_1->new(); # Vm_device_update_1 | 

eval { 
    $api_instance->vmDeviceIdIdPut(id => $id, body => $body);
};
if ($@) {
    warn "Exception when calling VmDeviceApi->vmDeviceIdIdPut: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.VmDeviceApi()
id = 56 # Integer | 
body =  # Vm_device_update_1 |  (optional)

try: 
    api_instance.vm_device_id_id_put(id, body=body)
except ApiException as e:
    print("Exception when calling VmDeviceApi->vmDeviceIdIdPut: %s\n" % e)

Parameters

Path parameters
Name Description
id*
Integer
Required
Body parameters
Name Description
body

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


vmDeviceNicAttachChoicesGet

Available choices for NIC Attach attribute.


/vm/device/nic_attach_choices

Usage and SDK Samples

curl -X GET -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/vm/device/nic_attach_choices"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.VmDeviceApi;

import java.io.File;
import java.util.*;

public class VmDeviceApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        VmDeviceApi apiInstance = new VmDeviceApi();
        try {
            apiInstance.vmDeviceNicAttachChoicesGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling VmDeviceApi#vmDeviceNicAttachChoicesGet");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::VmDeviceApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::VmDeviceApi->new();

eval { 
    $api_instance->vmDeviceNicAttachChoicesGet();
};
if ($@) {
    warn "Exception when calling VmDeviceApi->vmDeviceNicAttachChoicesGet: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.VmDeviceApi()

try: 
    api_instance.vm_device_nic_attach_choices_get()
except ApiException as e:
    print("Exception when calling VmDeviceApi->vmDeviceNicAttachChoicesGet: %s\n" % e)

Parameters

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


vmDevicePost

Create a new device for the VM of id `vm`. If `dtype` is the `RAW` type and a new raw file is to be created, `attributes.exists` will be passed as false. This means the API handles creating the raw file and raises the appropriate exception if file creation fails. If `dtype` is of `DISK` type and a new Zvol is to be created, `attributes.create_zvol` will be passed as true with valid `attributes.zvol_name` and `attributes.zvol_volsize` values.


/vm/device

Usage and SDK Samples

curl -X POST -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/vm/device"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.VmDeviceApi;

import java.io.File;
import java.util.*;

public class VmDeviceApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        VmDeviceApi apiInstance = new VmDeviceApi();
        Vm_device_create_0 body = ; // Vm_device_create_0 | 
        try {
            apiInstance.vmDevicePost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling VmDeviceApi#vmDevicePost");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::VmDeviceApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::VmDeviceApi->new();
my $body = WWW::SwaggerClient::Object::Vm_device_create_0->new(); # Vm_device_create_0 | 

eval { 
    $api_instance->vmDevicePost(body => $body);
};
if ($@) {
    warn "Exception when calling VmDeviceApi->vmDevicePost: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.VmDeviceApi()
body =  # Vm_device_create_0 |  (optional)

try: 
    api_instance.vm_device_post(body=body)
except ApiException as e:
    print("Exception when calling VmDeviceApi->vmDevicePost: %s\n" % e)

Parameters

Body parameters
Name Description
body

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


vmDevicePptdevChoicesGet

Available choices for PCI passthru device.


/vm/device/pptdev_choices

Usage and SDK Samples

curl -X GET -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/vm/device/pptdev_choices"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.VmDeviceApi;

import java.io.File;
import java.util.*;

public class VmDeviceApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        VmDeviceApi apiInstance = new VmDeviceApi();
        try {
            apiInstance.vmDevicePptdevChoicesGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling VmDeviceApi#vmDevicePptdevChoicesGet");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::VmDeviceApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::VmDeviceApi->new();

eval { 
    $api_instance->vmDevicePptdevChoicesGet();
};
if ($@) {
    warn "Exception when calling VmDeviceApi->vmDevicePptdevChoicesGet: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.VmDeviceApi()

try: 
    api_instance.vm_device_pptdev_choices_get()
except ApiException as e:
    print("Exception when calling VmDeviceApi->vmDevicePptdevChoicesGet: %s\n" % e)

Parameters

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


vmDeviceVncBindChoicesGet

Available choices for VNC Bind attribute.


/vm/device/vnc_bind_choices

Usage and SDK Samples

curl -X GET -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/vm/device/vnc_bind_choices"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.VmDeviceApi;

import java.io.File;
import java.util.*;

public class VmDeviceApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        VmDeviceApi apiInstance = new VmDeviceApi();
        try {
            apiInstance.vmDeviceVncBindChoicesGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling VmDeviceApi#vmDeviceVncBindChoicesGet");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::VmDeviceApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::VmDeviceApi->new();

eval { 
    $api_instance->vmDeviceVncBindChoicesGet();
};
if ($@) {
    warn "Exception when calling VmDeviceApi->vmDeviceVncBindChoicesGet: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.VmDeviceApi()

try: 
    api_instance.vm_device_vnc_bind_choices_get()
except ApiException as e:
    print("Exception when calling VmDeviceApi->vmDeviceVncBindChoicesGet: %s\n" % e)

Parameters

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


Vmware

vmwareDatasetHasVmsPost

Returns "true" if `dataset` is configured with a VMWare snapshot


/vmware/dataset_has_vms

Usage and SDK Samples

curl -X POST -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/vmware/dataset_has_vms"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.VmwareApi;

import java.io.File;
import java.util.*;

public class VmwareApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        VmwareApi apiInstance = new VmwareApi();
        Vmware_dataset_has_vms body = ; // Vmware_dataset_has_vms | 
        try {
            apiInstance.vmwareDatasetHasVmsPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling VmwareApi#vmwareDatasetHasVmsPost");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::VmwareApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::VmwareApi->new();
my $body = WWW::SwaggerClient::Object::Vmware_dataset_has_vms->new(); # Vmware_dataset_has_vms | 

eval { 
    $api_instance->vmwareDatasetHasVmsPost(body => $body);
};
if ($@) {
    warn "Exception when calling VmwareApi->vmwareDatasetHasVmsPost: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.VmwareApi()
body =  # Vmware_dataset_has_vms |  (optional)

try: 
    api_instance.vmware_dataset_has_vms_post(body=body)
except ApiException as e:
    print("Exception when calling VmwareApi->vmwareDatasetHasVmsPost: %s\n" % e)

Parameters

Body parameters
Name Description
body

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


vmwareGet


/vmware

Usage and SDK Samples

curl -X GET -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/vmware?limit=&offset=&count=&sort="
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.VmwareApi;

import java.io.File;
import java.util.*;

public class VmwareApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        VmwareApi apiInstance = new VmwareApi();
        Integer limit = 56; // Integer | 
        Integer offset = 56; // Integer | 
        Boolean count = true; // Boolean | 
        String sort = sort_example; // String | 
        try {
            apiInstance.vmwareGet(limit, offset, count, sort);
        } catch (ApiException e) {
            System.err.println("Exception when calling VmwareApi#vmwareGet");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::VmwareApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::VmwareApi->new();
my $limit = 56; # Integer | 
my $offset = 56; # Integer | 
my $count = true; # Boolean | 
my $sort = sort_example; # String | 

eval { 
    $api_instance->vmwareGet(limit => $limit, offset => $offset, count => $count, sort => $sort);
};
if ($@) {
    warn "Exception when calling VmwareApi->vmwareGet: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.VmwareApi()
limit = 56 # Integer |  (optional)
offset = 56 # Integer |  (optional)
count = true # Boolean |  (optional)
sort = sort_example # String |  (optional)

try: 
    api_instance.vmware_get(limit=limit, offset=offset, count=count, sort=sort)
except ApiException as e:
    print("Exception when calling VmwareApi->vmwareGet: %s\n" % e)

Parameters

Query parameters
Name Description
limit
Integer
offset
Integer
count
Boolean
sort
String

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


vmwareGetDatastoresPost

Get datastores from VMWare.


/vmware/get_datastores

Usage and SDK Samples

curl -X POST -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/vmware/get_datastores"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.VmwareApi;

import java.io.File;
import java.util.*;

public class VmwareApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        VmwareApi apiInstance = new VmwareApi();
        Vmware_get_datastores_0 body = ; // Vmware_get_datastores_0 | 
        try {
            apiInstance.vmwareGetDatastoresPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling VmwareApi#vmwareGetDatastoresPost");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::VmwareApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::VmwareApi->new();
my $body = WWW::SwaggerClient::Object::Vmware_get_datastores_0->new(); # Vmware_get_datastores_0 | 

eval { 
    $api_instance->vmwareGetDatastoresPost(body => $body);
};
if ($@) {
    warn "Exception when calling VmwareApi->vmwareGetDatastoresPost: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.VmwareApi()
body =  # Vmware_get_datastores_0 |  (optional)

try: 
    api_instance.vmware_get_datastores_post(body=body)
except ApiException as e:
    print("Exception when calling VmwareApi->vmwareGetDatastoresPost: %s\n" % e)

Parameters

Body parameters
Name Description
body

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


vmwareGetVirtualMachinesPost

Returns Virtual Machines on the VMWare host identified by `pk`.


/vmware/get_virtual_machines

Usage and SDK Samples

curl -X POST -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/vmware/get_virtual_machines"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.VmwareApi;

import java.io.File;
import java.util.*;

public class VmwareApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        VmwareApi apiInstance = new VmwareApi();
        Integer body = ; // Integer | 
        try {
            apiInstance.vmwareGetVirtualMachinesPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling VmwareApi#vmwareGetVirtualMachinesPost");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::VmwareApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::VmwareApi->new();
my $body = WWW::SwaggerClient::Object::Integer->new(); # Integer | 

eval { 
    $api_instance->vmwareGetVirtualMachinesPost(body => $body);
};
if ($@) {
    warn "Exception when calling VmwareApi->vmwareGetVirtualMachinesPost: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.VmwareApi()
body =  # Integer |  (optional)

try: 
    api_instance.vmware_get_virtual_machines_post(body=body)
except ApiException as e:
    print("Exception when calling VmwareApi->vmwareGetVirtualMachinesPost: %s\n" % e)

Parameters

Body parameters
Name Description
body

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


vmwareIdIdDelete

Delete VMWare snapshot of `id`.


/vmware/id/{id}

Usage and SDK Samples

curl -X DELETE -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/vmware/id/{id}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.VmwareApi;

import java.io.File;
import java.util.*;

public class VmwareApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        VmwareApi apiInstance = new VmwareApi();
        Integer id = 56; // Integer | 
        try {
            apiInstance.vmwareIdIdDelete(id);
        } catch (ApiException e) {
            System.err.println("Exception when calling VmwareApi#vmwareIdIdDelete");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::VmwareApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::VmwareApi->new();
my $id = 56; # Integer | 

eval { 
    $api_instance->vmwareIdIdDelete(id => $id);
};
if ($@) {
    warn "Exception when calling VmwareApi->vmwareIdIdDelete: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.VmwareApi()
id = 56 # Integer | 

try: 
    api_instance.vmware_id_id_delete(id)
except ApiException as e:
    print("Exception when calling VmwareApi->vmwareIdIdDelete: %s\n" % e)

Parameters

Path parameters
Name Description
id*
Integer
Required

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


vmwareIdIdGet


/vmware/id/{id}

Usage and SDK Samples

curl -X GET -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/vmware/id/{id}?limit=&offset=&count=&sort="
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.VmwareApi;

import java.io.File;
import java.util.*;

public class VmwareApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        VmwareApi apiInstance = new VmwareApi();
        array[null] id = ; // array[null] | 
        Integer limit = 56; // Integer | 
        Integer offset = 56; // Integer | 
        Boolean count = true; // Boolean | 
        String sort = sort_example; // String | 
        try {
            apiInstance.vmwareIdIdGet(id, limit, offset, count, sort);
        } catch (ApiException e) {
            System.err.println("Exception when calling VmwareApi#vmwareIdIdGet");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::VmwareApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::VmwareApi->new();
my $id = []; # array[null] | 
my $limit = 56; # Integer | 
my $offset = 56; # Integer | 
my $count = true; # Boolean | 
my $sort = sort_example; # String | 

eval { 
    $api_instance->vmwareIdIdGet(id => $id, limit => $limit, offset => $offset, count => $count, sort => $sort);
};
if ($@) {
    warn "Exception when calling VmwareApi->vmwareIdIdGet: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.VmwareApi()
id =  # array[null] | 
limit = 56 # Integer |  (optional)
offset = 56 # Integer |  (optional)
count = true # Boolean |  (optional)
sort = sort_example # String |  (optional)

try: 
    api_instance.vmware_id_id_get(id, limit=limit, offset=offset, count=count, sort=sort)
except ApiException as e:
    print("Exception when calling VmwareApi->vmwareIdIdGet: %s\n" % e)

Parameters

Path parameters
Name Description
id*
array[null]
Required
Query parameters
Name Description
limit
Integer
offset
Integer
count
Boolean
sort
String

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


vmwareIdIdPut

Update VMWare snapshot of `id`.


/vmware/id/{id}

Usage and SDK Samples

curl -X PUT -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/vmware/id/{id}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.VmwareApi;

import java.io.File;
import java.util.*;

public class VmwareApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        VmwareApi apiInstance = new VmwareApi();
        Integer id = 56; // Integer | 
        Vmware_update_1 body = ; // Vmware_update_1 | 
        try {
            apiInstance.vmwareIdIdPut(id, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling VmwareApi#vmwareIdIdPut");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::VmwareApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::VmwareApi->new();
my $id = 56; # Integer | 
my $body = WWW::SwaggerClient::Object::Vmware_update_1->new(); # Vmware_update_1 | 

eval { 
    $api_instance->vmwareIdIdPut(id => $id, body => $body);
};
if ($@) {
    warn "Exception when calling VmwareApi->vmwareIdIdPut: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.VmwareApi()
id = 56 # Integer | 
body =  # Vmware_update_1 |  (optional)

try: 
    api_instance.vmware_id_id_put(id, body=body)
except ApiException as e:
    print("Exception when calling VmwareApi->vmwareIdIdPut: %s\n" % e)

Parameters

Path parameters
Name Description
id*
Integer
Required
Body parameters
Name Description
body

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


vmwareMatchDatastoresWithDatasetsPost

Requests datastores from vCenter server and tries to match them with local filesystems. Returns a list of datastores, a list of local filesystems and guessed relationship between them.


/vmware/match_datastores_with_datasets

Usage and SDK Samples

curl -X POST -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/vmware/match_datastores_with_datasets"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.VmwareApi;

import java.io.File;
import java.util.*;

public class VmwareApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        VmwareApi apiInstance = new VmwareApi();
        Vmware_match_datastores_with_datasets_0 body = ; // Vmware_match_datastores_with_datasets_0 | 
        try {
            apiInstance.vmwareMatchDatastoresWithDatasetsPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling VmwareApi#vmwareMatchDatastoresWithDatasetsPost");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::VmwareApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::VmwareApi->new();
my $body = WWW::SwaggerClient::Object::Vmware_match_datastores_with_datasets_0->new(); # Vmware_match_datastores_with_datasets_0 | 

eval { 
    $api_instance->vmwareMatchDatastoresWithDatasetsPost(body => $body);
};
if ($@) {
    warn "Exception when calling VmwareApi->vmwareMatchDatastoresWithDatasetsPost: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.VmwareApi()
body =  # Vmware_match_datastores_with_datasets_0 |  (optional)

try: 
    api_instance.vmware_match_datastores_with_datasets_post(body=body)
except ApiException as e:
    print("Exception when calling VmwareApi->vmwareMatchDatastoresWithDatasetsPost: %s\n" % e)

Parameters

Body parameters
Name Description
body

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


vmwarePost

Create VMWare snapshot. `hostname` is a valid IP address / hostname of a VMWare host. When clustering, this is the vCenter server for the cluster. `username` and `password` are the credentials used to authorize access to the VMWare host. `datastore` is a valid datastore name which exists on the VMWare host.


/vmware

Usage and SDK Samples

curl -X POST -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/vmware"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.VmwareApi;

import java.io.File;
import java.util.*;

public class VmwareApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        VmwareApi apiInstance = new VmwareApi();
        Vmware_create_0 body = ; // Vmware_create_0 | 
        try {
            apiInstance.vmwarePost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling VmwareApi#vmwarePost");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::VmwareApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::VmwareApi->new();
my $body = WWW::SwaggerClient::Object::Vmware_create_0->new(); # Vmware_create_0 | 

eval { 
    $api_instance->vmwarePost(body => $body);
};
if ($@) {
    warn "Exception when calling VmwareApi->vmwarePost: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.VmwareApi()
body =  # Vmware_create_0 |  (optional)

try: 
    api_instance.vmware_post(body=body)
except ApiException as e:
    print("Exception when calling VmwareApi->vmwarePost: %s\n" % e)

Parameters

Body parameters
Name Description
body

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


Webdav

webdavGet


/webdav

Usage and SDK Samples

curl -X GET -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/webdav"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.WebdavApi;

import java.io.File;
import java.util.*;

public class WebdavApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        WebdavApi apiInstance = new WebdavApi();
        try {
            apiInstance.webdavGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling WebdavApi#webdavGet");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::WebdavApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::WebdavApi->new();

eval { 
    $api_instance->webdavGet();
};
if ($@) {
    warn "Exception when calling WebdavApi->webdavGet: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.WebdavApi()

try: 
    api_instance.webdav_get()
except ApiException as e:
    print("Exception when calling WebdavApi->webdavGet: %s\n" % e)

Parameters

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


webdavPut

Update Webdav Service Configuration. `protocol` specifies which protocol should be used for connecting to Webdav Serivce. Value of "HTTPHTTPS" allows both HTTP and HTTPS connections to the share. `certssl` is a valid id of a certificate configured in the system. This is required if HTTPS connection is desired with Webdave Service. There are 3 types of Authentication supported with Webdav: 1) NONE - No authentication is required 2) BASIC - Password is sent over the network as plaintext 3) DIGEST - Hash of the password is sent over the network `htauth` should be one of the valid types described above.


/webdav

Usage and SDK Samples

curl -X PUT -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/webdav"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.WebdavApi;

import java.io.File;
import java.util.*;

public class WebdavApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        WebdavApi apiInstance = new WebdavApi();
        Webdav_update_0 body = ; // Webdav_update_0 | 
        try {
            apiInstance.webdavPut(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling WebdavApi#webdavPut");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::WebdavApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::WebdavApi->new();
my $body = WWW::SwaggerClient::Object::Webdav_update_0->new(); # Webdav_update_0 | 

eval { 
    $api_instance->webdavPut(body => $body);
};
if ($@) {
    warn "Exception when calling WebdavApi->webdavPut: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.WebdavApi()
body =  # Webdav_update_0 |  (optional)

try: 
    api_instance.webdav_put(body=body)
except ApiException as e:
    print("Exception when calling WebdavApi->webdavPut: %s\n" % e)

Parameters

Body parameters
Name Description
body

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


WebuiImage

webuiImageGet


/webui/image

Usage and SDK Samples

curl -X GET -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/webui/image?limit=&offset=&count=&sort="
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.WebuiImageApi;

import java.io.File;
import java.util.*;

public class WebuiImageApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        WebuiImageApi apiInstance = new WebuiImageApi();
        Integer limit = 56; // Integer | 
        Integer offset = 56; // Integer | 
        Boolean count = true; // Boolean | 
        String sort = sort_example; // String | 
        try {
            apiInstance.webuiImageGet(limit, offset, count, sort);
        } catch (ApiException e) {
            System.err.println("Exception when calling WebuiImageApi#webuiImageGet");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::WebuiImageApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::WebuiImageApi->new();
my $limit = 56; # Integer | 
my $offset = 56; # Integer | 
my $count = true; # Boolean | 
my $sort = sort_example; # String | 

eval { 
    $api_instance->webuiImageGet(limit => $limit, offset => $offset, count => $count, sort => $sort);
};
if ($@) {
    warn "Exception when calling WebuiImageApi->webuiImageGet: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.WebuiImageApi()
limit = 56 # Integer |  (optional)
offset = 56 # Integer |  (optional)
count = true # Boolean |  (optional)
sort = sort_example # String |  (optional)

try: 
    api_instance.webui_image_get(limit=limit, offset=offset, count=count, sort=sort)
except ApiException as e:
    print("Exception when calling WebuiImageApi->webuiImageGet: %s\n" % e)

Parameters

Query parameters
Name Description
limit
Integer
offset
Integer
count
Boolean
sort
String

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


webuiImageIdIdDelete

Remove the database entry, and then the item if it exists


/webui/image/id/{id}

Usage and SDK Samples

curl -X DELETE -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/webui/image/id/{id}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.WebuiImageApi;

import java.io.File;
import java.util.*;

public class WebuiImageApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        WebuiImageApi apiInstance = new WebuiImageApi();
        Integer id = 56; // Integer | 
        try {
            apiInstance.webuiImageIdIdDelete(id);
        } catch (ApiException e) {
            System.err.println("Exception when calling WebuiImageApi#webuiImageIdIdDelete");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::WebuiImageApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::WebuiImageApi->new();
my $id = 56; # Integer | 

eval { 
    $api_instance->webuiImageIdIdDelete(id => $id);
};
if ($@) {
    warn "Exception when calling WebuiImageApi->webuiImageIdIdDelete: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.WebuiImageApi()
id = 56 # Integer | 

try: 
    api_instance.webui_image_id_id_delete(id)
except ApiException as e:
    print("Exception when calling WebuiImageApi->webuiImageIdIdDelete: %s\n" % e)

Parameters

Path parameters
Name Description
id*
Integer
Required

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


webuiImageIdIdGet


/webui/image/id/{id}

Usage and SDK Samples

curl -X GET -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/webui/image/id/{id}?limit=&offset=&count=&sort="
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.WebuiImageApi;

import java.io.File;
import java.util.*;

public class WebuiImageApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        WebuiImageApi apiInstance = new WebuiImageApi();
        array[null] id = ; // array[null] | 
        Integer limit = 56; // Integer | 
        Integer offset = 56; // Integer | 
        Boolean count = true; // Boolean | 
        String sort = sort_example; // String | 
        try {
            apiInstance.webuiImageIdIdGet(id, limit, offset, count, sort);
        } catch (ApiException e) {
            System.err.println("Exception when calling WebuiImageApi#webuiImageIdIdGet");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::WebuiImageApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::WebuiImageApi->new();
my $id = []; # array[null] | 
my $limit = 56; # Integer | 
my $offset = 56; # Integer | 
my $count = true; # Boolean | 
my $sort = sort_example; # String | 

eval { 
    $api_instance->webuiImageIdIdGet(id => $id, limit => $limit, offset => $offset, count => $count, sort => $sort);
};
if ($@) {
    warn "Exception when calling WebuiImageApi->webuiImageIdIdGet: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.WebuiImageApi()
id =  # array[null] | 
limit = 56 # Integer |  (optional)
offset = 56 # Integer |  (optional)
count = true # Boolean |  (optional)
sort = sort_example # String |  (optional)

try: 
    api_instance.webui_image_id_id_get(id, limit=limit, offset=offset, count=count, sort=sort)
except ApiException as e:
    print("Exception when calling WebuiImageApi->webuiImageIdIdGet: %s\n" % e)

Parameters

Path parameters
Name Description
id*
array[null]
Required
Query parameters
Name Description
limit
Integer
offset
Integer
count
Boolean
sort
String

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


ZfsSnapshot

zfsSnapshotClonePost

Clone a given snapshot to a new dataset. Returns: bool: True if succeed otherwise False.


/zfs/snapshot/clone

Usage and SDK Samples

curl -X POST -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/zfs/snapshot/clone"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.ZfsSnapshotApi;

import java.io.File;
import java.util.*;

public class ZfsSnapshotApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        ZfsSnapshotApi apiInstance = new ZfsSnapshotApi();
        Zfs_snapshot_clone_0 body = ; // Zfs_snapshot_clone_0 | 
        try {
            apiInstance.zfsSnapshotClonePost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling ZfsSnapshotApi#zfsSnapshotClonePost");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::ZfsSnapshotApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::ZfsSnapshotApi->new();
my $body = WWW::SwaggerClient::Object::Zfs_snapshot_clone_0->new(); # Zfs_snapshot_clone_0 | 

eval { 
    $api_instance->zfsSnapshotClonePost(body => $body);
};
if ($@) {
    warn "Exception when calling ZfsSnapshotApi->zfsSnapshotClonePost: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.ZfsSnapshotApi()
body =  # Zfs_snapshot_clone_0 |  (optional)

try: 
    api_instance.zfs_snapshot_clone_post(body=body)
except ApiException as e:
    print("Exception when calling ZfsSnapshotApi->zfsSnapshotClonePost: %s\n" % e)

Parameters

Body parameters
Name Description
body

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


zfsSnapshotGet

Query all ZFS Snapshots with `query-filters` and `query-options`.


/zfs/snapshot

Usage and SDK Samples

curl -X GET -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/zfs/snapshot?limit=&offset=&count=&sort="
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.ZfsSnapshotApi;

import java.io.File;
import java.util.*;

public class ZfsSnapshotApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        ZfsSnapshotApi apiInstance = new ZfsSnapshotApi();
        Integer limit = 56; // Integer | 
        Integer offset = 56; // Integer | 
        Boolean count = true; // Boolean | 
        String sort = sort_example; // String | 
        try {
            apiInstance.zfsSnapshotGet(limit, offset, count, sort);
        } catch (ApiException e) {
            System.err.println("Exception when calling ZfsSnapshotApi#zfsSnapshotGet");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::ZfsSnapshotApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::ZfsSnapshotApi->new();
my $limit = 56; # Integer | 
my $offset = 56; # Integer | 
my $count = true; # Boolean | 
my $sort = sort_example; # String | 

eval { 
    $api_instance->zfsSnapshotGet(limit => $limit, offset => $offset, count => $count, sort => $sort);
};
if ($@) {
    warn "Exception when calling ZfsSnapshotApi->zfsSnapshotGet: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.ZfsSnapshotApi()
limit = 56 # Integer |  (optional)
offset = 56 # Integer |  (optional)
count = true # Boolean |  (optional)
sort = sort_example # String |  (optional)

try: 
    api_instance.zfs_snapshot_get(limit=limit, offset=offset, count=count, sort=sort)
except ApiException as e:
    print("Exception when calling ZfsSnapshotApi->zfsSnapshotGet: %s\n" % e)

Parameters

Query parameters
Name Description
limit
Integer
offset
Integer
count
Boolean
sort
String

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


zfsSnapshotIdIdDelete

Delete snapshot of name `id`. `options.defer` will defer the deletion of snapshot.


/zfs/snapshot/id/{id}

Usage and SDK Samples

curl -X DELETE -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/zfs/snapshot/id/{id}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.ZfsSnapshotApi;

import java.io.File;
import java.util.*;

public class ZfsSnapshotApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        ZfsSnapshotApi apiInstance = new ZfsSnapshotApi();
        String id = id_example; // String | 
        Zfs_snapshot_delete_1 body = ; // Zfs_snapshot_delete_1 | 
        try {
            apiInstance.zfsSnapshotIdIdDelete(id, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling ZfsSnapshotApi#zfsSnapshotIdIdDelete");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::ZfsSnapshotApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::ZfsSnapshotApi->new();
my $id = id_example; # String | 
my $body = WWW::SwaggerClient::Object::Zfs_snapshot_delete_1->new(); # Zfs_snapshot_delete_1 | 

eval { 
    $api_instance->zfsSnapshotIdIdDelete(id => $id, body => $body);
};
if ($@) {
    warn "Exception when calling ZfsSnapshotApi->zfsSnapshotIdIdDelete: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.ZfsSnapshotApi()
id = id_example # String | 
body =  # Zfs_snapshot_delete_1 |  (optional)

try: 
    api_instance.zfs_snapshot_id_id_delete(id, body=body)
except ApiException as e:
    print("Exception when calling ZfsSnapshotApi->zfsSnapshotIdIdDelete: %s\n" % e)

Parameters

Path parameters
Name Description
id*
String
Required
Body parameters
Name Description
body

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


zfsSnapshotIdIdGet

Query all ZFS Snapshots with `query-filters` and `query-options`.


/zfs/snapshot/id/{id}

Usage and SDK Samples

curl -X GET -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/zfs/snapshot/id/{id}?limit=&offset=&count=&sort="
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.ZfsSnapshotApi;

import java.io.File;
import java.util.*;

public class ZfsSnapshotApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        ZfsSnapshotApi apiInstance = new ZfsSnapshotApi();
        array[null] id = ; // array[null] | 
        Integer limit = 56; // Integer | 
        Integer offset = 56; // Integer | 
        Boolean count = true; // Boolean | 
        String sort = sort_example; // String | 
        try {
            apiInstance.zfsSnapshotIdIdGet(id, limit, offset, count, sort);
        } catch (ApiException e) {
            System.err.println("Exception when calling ZfsSnapshotApi#zfsSnapshotIdIdGet");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::ZfsSnapshotApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::ZfsSnapshotApi->new();
my $id = []; # array[null] | 
my $limit = 56; # Integer | 
my $offset = 56; # Integer | 
my $count = true; # Boolean | 
my $sort = sort_example; # String | 

eval { 
    $api_instance->zfsSnapshotIdIdGet(id => $id, limit => $limit, offset => $offset, count => $count, sort => $sort);
};
if ($@) {
    warn "Exception when calling ZfsSnapshotApi->zfsSnapshotIdIdGet: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.ZfsSnapshotApi()
id =  # array[null] | 
limit = 56 # Integer |  (optional)
offset = 56 # Integer |  (optional)
count = true # Boolean |  (optional)
sort = sort_example # String |  (optional)

try: 
    api_instance.zfs_snapshot_id_id_get(id, limit=limit, offset=offset, count=count, sort=sort)
except ApiException as e:
    print("Exception when calling ZfsSnapshotApi->zfsSnapshotIdIdGet: %s\n" % e)

Parameters

Path parameters
Name Description
id*
array[null]
Required
Query parameters
Name Description
limit
Integer
offset
Integer
count
Boolean
sort
String

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


zfsSnapshotPost

Take a snapshot from a given dataset. Returns: bool: True if succeed otherwise False.


/zfs/snapshot

Usage and SDK Samples

curl -X POST -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/zfs/snapshot"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.ZfsSnapshotApi;

import java.io.File;
import java.util.*;

public class ZfsSnapshotApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        ZfsSnapshotApi apiInstance = new ZfsSnapshotApi();
        Zfs_snapshot_create_0 body = ; // Zfs_snapshot_create_0 | 
        try {
            apiInstance.zfsSnapshotPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling ZfsSnapshotApi#zfsSnapshotPost");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::ZfsSnapshotApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::ZfsSnapshotApi->new();
my $body = WWW::SwaggerClient::Object::Zfs_snapshot_create_0->new(); # Zfs_snapshot_create_0 | 

eval { 
    $api_instance->zfsSnapshotPost(body => $body);
};
if ($@) {
    warn "Exception when calling ZfsSnapshotApi->zfsSnapshotPost: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.ZfsSnapshotApi()
body =  # Zfs_snapshot_create_0 |  (optional)

try: 
    api_instance.zfs_snapshot_post(body=body)
except ApiException as e:
    print("Exception when calling ZfsSnapshotApi->zfsSnapshotPost: %s\n" % e)

Parameters

Body parameters
Name Description
body

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


zfsSnapshotRemovePost

Remove a snapshot from a given dataset. Returns: bool: True if succeed otherwise False.


/zfs/snapshot/remove

Usage and SDK Samples

curl -X POST -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/zfs/snapshot/remove"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.ZfsSnapshotApi;

import java.io.File;
import java.util.*;

public class ZfsSnapshotApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        ZfsSnapshotApi apiInstance = new ZfsSnapshotApi();
        Zfs_snapshot_remove_0 body = ; // Zfs_snapshot_remove_0 | 
        try {
            apiInstance.zfsSnapshotRemovePost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling ZfsSnapshotApi#zfsSnapshotRemovePost");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::ZfsSnapshotApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::ZfsSnapshotApi->new();
my $body = WWW::SwaggerClient::Object::Zfs_snapshot_remove_0->new(); # Zfs_snapshot_remove_0 | 

eval { 
    $api_instance->zfsSnapshotRemovePost(body => $body);
};
if ($@) {
    warn "Exception when calling ZfsSnapshotApi->zfsSnapshotRemovePost: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.ZfsSnapshotApi()
body =  # Zfs_snapshot_remove_0 |  (optional)

try: 
    api_instance.zfs_snapshot_remove_post(body=body)
except ApiException as e:
    print("Exception when calling ZfsSnapshotApi->zfsSnapshotRemovePost: %s\n" % e)

Parameters

Body parameters
Name Description
body

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


zfsSnapshotRollbackPost

Rollback to a given snapshot `id`. `options.recursive` will destroy any snapshots and bookmarks more recent than the one specified. `options.recursive_clones` is just like `recursive` but will also destroy any clones. `options.force` will force unmount of any clones.


/zfs/snapshot/rollback

Usage and SDK Samples

curl -X POST -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/zfs/snapshot/rollback"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.ZfsSnapshotApi;

import java.io.File;
import java.util.*;

public class ZfsSnapshotApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        ZfsSnapshotApi apiInstance = new ZfsSnapshotApi();
        Zfs_snapshot_rollback body = ; // Zfs_snapshot_rollback | 
        try {
            apiInstance.zfsSnapshotRollbackPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling ZfsSnapshotApi#zfsSnapshotRollbackPost");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::ZfsSnapshotApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::ZfsSnapshotApi->new();
my $body = WWW::SwaggerClient::Object::Zfs_snapshot_rollback->new(); # Zfs_snapshot_rollback | 

eval { 
    $api_instance->zfsSnapshotRollbackPost(body => $body);
};
if ($@) {
    warn "Exception when calling ZfsSnapshotApi->zfsSnapshotRollbackPost: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.ZfsSnapshotApi()
body =  # Zfs_snapshot_rollback |  (optional)

try: 
    api_instance.zfs_snapshot_rollback_post(body=body)
except ApiException as e:
    print("Exception when calling ZfsSnapshotApi->zfsSnapshotRollbackPost: %s\n" % e)

Parameters

Body parameters
Name Description
body

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint